Ejemplo de compañero en clase - Macros

Archivo de texto -------
 inicializa MACRO
 mov ax,data
 mov ds, ax
 mov cx,9
 mov di, offset max
 mov si,offset a
ENDM



Codigo ----


INCLUDE mac.TXT

.model small
.stack

.data
a db 12,13,14,15,50,32,12,99
max db 0
numero db '12$'
diez db 10
msg1 db 'numero mas grande de la pila =  $'
msg2 db 10,13,'caracter ascii =  $'

.code
INICIO:
inicializa

comparar:
    mov al,[si] ;mueve si numero del vector
    mov bl,[di] ;guarda numero mas grande
    cmp bl,al   ;si es el mayor
    jnb incrementa ;salta a incremente
    mov [di], al   ;guarda numero a comparar en la siguiente vuelta

incrementa:
    inc si
    loop comparar
    ;convertir el numero a cadenta intToString
    mov al, max
    mov ah,0
    div diez
    add ah, '0'
    mov numero[1], ah
    add al, '0'
    mov numero[0], al
    ;desplegar el mensaje
    mov dx, offset msg1
    mov ah, 09h
    int 21h
    mov dx, offset numero
    mov ah, 09h
    int 21h
    mov dx, offset msg2
    mov ah, 09h
    int 21h
    mov dl,[di]
    mov ah, 02h
    int 21h
    mov ah, 4ch
    int 21h
end inicio
end

Metodos de Ordenamiento (PDF)

http://novella.mhhe.com/sites/dl/free/844814077x/619434/A06.pdf

Librerias de Python, Uso de PIP, MySQLdb

Introducir módulos

Una de las principales ventajas de utilizar Python es el número de librerías o bibliotecas de código excelentes que están amplia y fácilmente disponibles y que te pueden ahorrar escribir mucho código, o simplemente realizar una tarea particular de la manera más sencilla (como crear un archivo CSV o recopilar información de una página web de forma automática -webscraping). Cuando buscas en Google soluciones a problemas, encuentras ejemplos de código que utilizan librerías de las cuales no habías escuchado hablar antes. ¡No tengas miedo! Una vez que estas bibliotecas están instaladas en tu computadora, puedes utilizarlas importándolas al principio de tu código. Puedes importar tantas librerías como quieras, por ejemplo:

import csv
import requests
import kmlwriter
import pprint

Para los nuevos usuarios de Python puede resultar un tanto intimidante descargar e instalar por primera vez módulos externos. Hay muchas maneras de hacerlo (aumentando así la confusión); esta lección explica una de las formas más sencillas y la más común de instalar módulos de Python.
El objetivo aquí es instalar software en tu computadora que puede descargar e instalar automáticamente los módulos de Python. Utilizaremos el programa llamado pip.

Nota: En Python 3.4, pip está incluido en la instalación por defecto. Hay muchas razones por las que no debes tener todavía esta versión; en caso de que no la tengas, estas instrucciones deben ayudar.

Instrucciones para Mac y Linux

Según la documentación de pip, podemos descargar una secuencia de comandos (script) Python para instalarlo. En una Mac o Linux debemos instalar pip con línea de comandos usando curl, que es una orden que descarga el script de Perl y que permite la instalación de pip.

curl -O https://bootstrap.pypa.io/get-pip.py

Una vez que descargaste el archivo get-pip.py, necesitas ejecutarlo con el intérprete de Python. Sin embargo, si intentas ejecutar el script con Python de esta manera:

python get-pip.py

La secuencia de comandos del script seguramante falle. Esto se debe a que no tiene permisos para actualizar ciertos directorios en tu sistema de archivos para evitar que scripts aleatorios puedan cambiar archivos importantes e instalarte virus. En este caso, y en todos los casos en que necesites dar permiso a un script seguro para escribir en las carpetas del sistema, puedes utilizar el comando sudo (abreviatura de “Super User DO”) delante del comando Python, como:

sudo python get-pip.py

Instrucciones para Windows

Como en los sistemas operativos anteriores, la manera más fácil de instalar pip es utilizando el programa de Python llamado get-pip.py, que puedes descargar aquí. Cuando abres este enlace te puede asustar el revoltijo horrible que te espera. Por favor, no te espantes. Solamente usa tu navegador para guardar esta página con su nombre por defecto, que es get-pip.py. Guarda el archivo en tu directorio de Python para que sepas dónde encontrarlo.
Una vez guardes el archivo, necesitas ejecutarlo, lo cual puedes hacer de dos maneras. Si prefieres utilizar tu intérprete de Python, solamente haz click con el botón derecho sobre el archivo get-pip.py y selecciona “abrir con” y luego selecciona el intérprete de Python que suelas utilizar.
Si prefieres instalar pip utilizando la terminal de línea de comandos, navega al directorio en el que pusiste Python y obtén get-pip.py. Para este ejemplo asumimos el directorio python27, así que usa el comando C:\>cd python27. Una vez que estés en este directorio, ejecuta el comando:

python get-pip.py to install pip

Si buscas más información consulta la página de StackOverflow que parece estar actualizada de manera regular.

Instalar módulos de Python

Ahora que ya tienes pip, resultará fácil instalar los módulos de Python dado que el programa hace todo el trabajo por ti. Cuando encuentres un módulo que quieras utilizar, generalmente tendrá documentación o instrucciones de instalación que incluyan el comando pip necesario, como:

pip install requests
pip install beautifulsoup4
pip install simplekml

Trabajando con bases de datos MySQL en Python

No abordaremos aquí, conocimientos básicos sobre MySQL, uso, instalación ni configuración. Sin perjuicio de lo anterior, haré una breve introducción.

Structured Query Language (SQL)

SQL es el lenguaje de consulta estructurado utilizado para el acceso a bases de datos relacionales. Si bien SQL como lenguaje, posee ciertos estándares, el lenguaje de consulta en sí, varía para cada base de datos en particular, siendo el tratado en este ejemplo, el correspondiente a MySQL.

MySQL

MySQL es un sistema de gestión de bases de datos relacionales, libre y que puede ser instalado en múltiples plataformas.
Para seguir el capítulo de esta guía, será necesario instalar MySQL. Para ello los invito a quienes no posean MySQL instalado, que visiten el sitio de descargas de MySQL y la documentación de MySQL.

MySQLdb

MySQLdb es una interfaz para trabajar con bases de datos MySQL desde Python. El capítulo Nº7 de esta guía, se ha indicado como lectura recomendada, el Manual oficial de MySQLdb el cual sugiero que se lea tras finalizar este capítulo.

Instalación de MySQLdb

Para interactuar desde Python con MySQL a través de MySQLdb, es necesario instalar dicho módulo. El nombre del paquete es python-mysqldb (por si desean instalarlo desde los repositorios), o sino, pueden descargar un tarball desde http://sourceforge.net/projects/mysql-python/. Allí mismo, encontrarán el archivo README con toda la información para instalarlo.

Introducción a bases de datos con Python

En el caso particular de Python, el acceso a bases de datos se encuentra definido a modo de estándar en las especificaciones de DB-API (por curiosidad, puedes visitar Python Database API specification).
Esto significa, que para utilizar cualquier base de datos, siempre se deberán seguir los mismos pasos:

1. Importar el módulo de conexión (en nuestro caso, utilizaremos MySQLdb)
   import MySQLdb
2. Conectarse a la base de datos
   
db_host = 'localhost'
usuario = 'root'
clave = 'clave'
base_de_datos = 'mi_basededatos' db = MySQLdb.connect(host=db_host, user=usuario, passwd=clave,
db=base_de_datos)

3. Abrir un cursor
   cursor = db.cursor()
4. Ejecutar una consulta
   
mi_query = "SELECT campo FROM tabla WHERE campo='valor' ORDER BY campo"
cursor.execute(mi_query)

5. Si se está agregando, editando o eliminando un registro: hacer un commit a la base de datos
   db.commit()
6. Si se están leyendo datos: obtener todos los registros hallados
   cursor.fetchall() u obtener solo el primero:
   cursor.fetchone()
7. Cerrar el cursor abierto
   cursor.close()

Pip (administrador de paquetes) Python

pip es un sistema de gestión de paquetes utilizado para instalar y administrar paquetes de software escritos en Python. Muchos paquetes pueden ser encontrados en el Python Package Index (PyPI). Python 2.7.9 y posteriores (en la serie Python2), Python 3.4 y posteriores incluyen pip (pip3 para Python3) por defecto.

pip es un acrónimo recursivo que se puede interpretar como Pip Instalador de Paquetes o Pip Instalador de Python.

Una ventaja importante de pip es la facilidad de su interfaz de línea de comandos, el cual permite instalar paquetes de software de Python fácilmente desde solo una orden:

pip install nombre-paquete

Los usuarios también pueden fácilmente desinstalar algún paquete:

pip uninstall nombre-paquete

Multiplicación en Macros

.model small
.stack

.data        ;definición de datos(variables), donde se almacenara información
.code
   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0
.startup
   ;cls
   operacion macro a, b, c, d ;creacion de macro operacion con 4 parametros
   mov al,a  ;unidad del segundo numero
   mov bl,b  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0
   aam          ;separamos de hex a dec
   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion
           
   mov al,a  ;unidades del segundo numero
   mov bl,d  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec
   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1
 
     
 
   mov al,c    ;al = chr3
   mov bl,b    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,c    ;AL = chr3
   mov bl,d    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
   endm
 
   ;suma final
   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero
 
   suma macro respuesta3,respuesta2,respuesta1,acomulador ;creacion de macro suma con 4 parametros
   mov ax,0000h   ;limpiamos ax
 
   mov al,respuesta3      ;movemos el segundo resultado de la primera mult a al
   mov bl,respuesta2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec
   mov respuesta3,al      ;r3 guarda las decenas del resultado final
   mov respuesta2,ah      ;r2 se utiliza como nuevo acarreo
 
   mov ax,0000h   ;''''
 
   mov al,acomulador     ;movemos el acarreo de la primera mult a al
   mov bl,respuesta1      ;movemos segundo resultado de la segunda mult a bl
   add al,respuesta2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl
   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec
   mov respuesta1,al      ;r1 guarda las centenas
   mov respuesta2,ah      ;ah se sigue utilizando como acarreo
 
   mov al,respuesta2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final
   endm
 
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h

   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
 
   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions
   
 
 
   ;Realizamos operaci?n
   operacion chr4,chr2,chr3,chr1 ;llamada al macro con parametros
   suma r3,r2,r1,ac1 ;llamada al macro con parametros
 

   mov ah,02h 
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)

   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r1 (centena)

                 
 
   mov ah,02H
   mov dl,r3
   add dl,30h
   int 21h        ;Mostramos r3 (decena)
 
   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h        ;unidad       
 


.exit
end

Procedimientos en MYSQL

 Procedimientos almacenados y las tablas de permisos

Los procedimientos almacenados requieren la tabla proc en la base de datos mysql. Esta tabla se crea durante la isntalación de MySQL 5.0. Si está actualizando a MySQL 5.0 desde una versión anterior, asegúrese de actualizar sus tablas de permisos para asegurar que la tabla proc existe. Consulte Sección 2.10.2, “Aumentar la versión de las tablas de privilegios”.

Desde MySQL 5.0.3, el sistema de permisos se ha modificado para tener en cuenta los procedimientos almacenados como sigue:

• El permiso CREATE ROUTINE se necesita para crear procedimientos almacenados.
• El permiso ALTER ROUTINE se necesita para alterar o borrar procedimientos almacenados. Este permiso se da automáticamente al creador de una rutina.
• El permiso EXECUTE se requiere para ejectuar procedimientos almacenados. Sin embargo, este permiso se da automáticamente al creador de la rutina. También, la característica SQL SECURITY por defecto para una rutina es DEFINER, lo que permite a los usuarios que tienen acceso a la base de datos ejecutar la rutina asociada.

Los procedimientos almacenados y rutinas se crean con comandos CREATE PROCEDURE y CREATE FUNCTION . Una rutina es un procedimiento o una función. Un procedimiento se invoca usando un comando CALL , y sólo puede pasar valores usando variables de salida. Una función puede llamarse desde dentro de un comando como cualquier otra función (esto es, invocando el nombre de la función), y puede retornar un valor escalar. Las rutinas almacenadas pueden llamar otras rutinas almacenadas.

Desde MySQL 5.0.1, los procedimientos almacenadoso funciones se asocian con una base de datos. Esto tiene varias implicaciones:

• Cunado se invoca la rutina, se realiza implícitamente USE db_name ( y se deshace cuando acaba la rutina). Los comandos USE dentro de procedimientos almacenados no se permiten.
• Puede calificar los nombres de rutina con el nombre de la base de datos. Esto puede usarse para referirse a una rutina que no esté en la base de datos actual. Por ejemplo, para invocar procedimientos almacenados p o funciones f esto se asocia con la base de datos test , puede decir CALL test.p() o test.f().
• Cuando se borra una base de datos, todos los procedimientos almacenados asociados con ella también se borran.

(En MySQL 5.0.0, los procedimientos almacenados son globales y no asociados con una base de datos. Heredan la base de datos por defecto del llamador. Si se ejecuta USE db_name desde la rutina, la base de datos por defecto original se restaura a la salida de la rutina.)

MySQL soporta la extensión muy útil que permite el uso de comandos regulares SELECT (esto es, sin usar cursores o variables locales) dentro de los procedimientos almacenados. El conjunto de resultados de estas consultas se envía diractamente al cliente. Comandos SELECT múltiples generan varios conjuntos de resultados, así que el cliente debe usar una biblioteca cliente de MySQL que soporte conjuntos de resultados múltiples. Esto significa que el cliente debe usar una biblioteca cliente de MySQL como mínimos desde 4.1.

La siguiente sección describe la sintaxis usada para crear, alterar, borrar, y consultar procedimientos almacenados y funciones.

19.2.1. CREATE PROCEDURE y CREATE FUNCTION

CREATE PROCEDURE sp_name ([parameter[,...]])
    [characteristic ...] routine_body

CREATE FUNCTION sp_name ([parameter[,...]])
    RETURNS type
    [characteristic ...] routine_body

parameter:
    [ IN | OUT | INOUT ] param_name type

type:
    Any valid MySQL data type

characteristic:
    LANGUAGE SQL
  | [NOT] DETERMINISTIC
  | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
  | SQL SECURITY { DEFINER | INVOKER }
  | COMMENT 'string'

routine_body:
    procedimientos almacenados o comandos SQL válidos

Estos comandos crean una rutina almacenada. Desde MySQL 5.0.3, para crear una rutina, es necesario tener el permiso CREATE ROUTINE , y los permisos ALTER ROUTINE y EXECUTE se asignan automáticamente a su creador. Si se permite logueo binario necesita también el permisos SUPERcomo se describe en Sección 19.3, “Registro binario de procedimientos almacenados y disparadores”.

Por defecto, la rutina se asocia con la base de datos actual. Para asociar la rutina explícitamente con una base de datos, especifique el nombre como db_name.sp_name al crearlo.

Si el nombre de rutina es el mismo que el nombre de una función de SQL, necesita usar un espacio entre el nombre y el siguiente paréntesis al definir la rutina, o hay un error de sintaxis. Esto también es cierto cuando invoca la rutina posteriormente.

La cláusula RETURNS puede especificarse sólo con FUNCTION, donde es obligatorio. Se usa para indicar el tipo de retorno de la función, y el cuerpo de la función debe contener un comando RETURN value.

La lista de parámetros entre paréntesis debe estar siempre presente. Si no hay parámetros, se debe usar una lista de parámetros vacía () . Cada parámetro es un parámetro IN por defecto. Para especificar otro tipo de parámetro, use la palabra clave OUT o INOUT antes del nombre del parámetro. Especificando IN, OUT, o INOUT sólo es valido para una PROCEDURE.

El comando CREATE FUNCTION se usa en versiones anteriores de MySQL para soportar UDFs (User Defined Functions) (Funciones Definidas por el Usuario). Consulte Sección 27.2, “Añadir nuevas funciones a MySQL”. UDFs se soportan, incluso con la existencia de procedimientos almacenados. Un UDF puede tratarse como una función almacenada externa. Sin embargo, tenga en cuenta que los procedimientos almacenados comparten su espacio de nombres con UDFs.

Un marco para procedimientos almacenados externos se introducirá en el futuro. Esto permitira escribir procedimientos almacenados en lenguajes distintos a SQL. Uno de los primeros lenguajes a soportar será PHP ya que el motor central de PHP es pequeño, con flujos seguros y puede empotrarse fácilmente. Como el marco es público, se espera soportar muchos otros lenguajes.

Un procedimiento o función se considera “determinista” si siempre produce el mismo resultado para los mismos parámetros de entrada, y “no determinista” en cualquier otro caso. Si no se da niDETERMINISTIC ni NOT DETERMINISTIC por defecto es NOT DETERMINISTIC.

Para replicación, use la función NOW() (o su sinónimo) o RAND() no hace una rutina no determinista necesariamente. Para NOW(), el log binario incluye el tiempo y hora y replica correctamente. RAND()también replica correctamente mientras se invoque sólo una vez dentro de una rutina. (Puede considerar el tiempo y hora de ejecución de la rutina y una semilla de número aleatorio como entradas implícitas que son idénticas en el maestro y el esclavo.)

Actualmente, la característica DETERMINISTIC se acepta, pero no la usa el optimizador. Sin embargo, si se permite el logueo binario, esta característica afecta si MySQL acepta definición de rutinas. Consulte Sección 19.3, “Registro binario de procedimientos almacenados y disparadores”.

Varias características proporcionan información sobre la naturaleza de los datos usados por la rutina. CONTAINS SQL indica que la rutina no contiene comandos que leen o escriben datos. NO SQL indica que la rutina no contiene comandos SQL . READS SQL DATA indica que la rutina contiene comandos que leen datos, pero no comandos que escriben datos. MODIFIES SQL DATA indica que la rutina contiene comandos que pueden escribir datos. CONTAINS SQL es el valor por defecto si no se dan explícitamente ninguna de estas características.

La característica SQL SECURITY puede usarse para especificar si la rutina debe ser ejecutada usando los permisos del usuario que crea la rutina o el usuario que la invoca. El valor por defecto es DEFINER. Esta característica es nueva en SQL:2003. El creador o el invocador deben tener permisos para acceder a la base de datos con la que la rutina está asociada. Desde MySQL 5.0.3, es necesario tener el permiso EXECUTE para ser capaz de ejecutar la rutina. El usuario que debe tener este permiso es el definidor o el invocador, en función de cómo la característica SQL SECURITY .

MySQL almacena la variable de sistema sql_mode que está en efecto cuando se crea la rutina, y siempre ejecuta la rutina con esta inicialización.

La cláusula COMMENT es una extensión de MySQL, y puede usarse para describir el procedimiento almacenado. Esta información se muestra con los comandos SHOW CREATE PROCEDURE y SHOW CREATE FUNCTION .

MySQL permite a las rutinas que contengan comandos DDL (tales como CREATE y DROP) y comandos de transacción SQL (como COMMIT). Esto no lo requiere el estándar, y por lo tanto, es específico de la implementación.

Los procedimientos almacenados no pueden usar LOAD DATA INFILE.

Nota: Actualmente, los procedimientos almacenados creados con CREATE FUNCTION no pueden tener referencias a tablas. (Esto puede incluir algunos comandos SET que pueden contener referencias a tablas, por ejemplo SET a:= (SELECT MAX(id) FROM t), y por otra parte no pueden contener comandos SELECT , por ejemplo SELECT 'Hello world!' INTO var1.) Esta limitación se elminará en breve.

Los comandos que retornan un conjunto de resultados no pueden usarse desde una función almacenada. Esto incluye comandos SELECT que no usan INTO para tratar valores de columnas en variables, comandos SHOW y otros comandos como EXPLAIN. Para comandos que pueden determinarse al definir la función para que retornen un conjunto de resultados, aparece un mensaje de error Not allowed to return a result set from a function (ER_SP_NO_RETSET_IN_FUNC). Para comandos que puede determinarse sólo en tiempo de ejecución si retornan un conjunto de resultados, aparece el error PROCEDURE %s can't return a result set in the given context(ER_SP_BADSELECT).

El siguiente es un ejemplo de un procedimiento almacenado que use un parámetro OUT . El ejemplo usa el cliente mysql y el comando delimiter para cambiar el delimitador del comando de ; a //mientras se define el procedimiento . Esto permite pasar el delimitador ; usado en el cuerpo del procedimiento a través del servidor en lugar de ser interpretado por el mismo mysql.

Enlace a información:

https://manuales.guebs.com/mysql-5.0/stored-procedures.html#variables-in-stored-procedures

Mysql WorkBench - Procedimientos

Creacion de procedimientos en mysql:

1 2	CREATE PROCEDURE nombre (parámetros)       [características] definición

Ejemplo:

DELIMITER $$

create procedure EDITORIAL_CONSULTA(IN dato int)

begin

select * from editoriales where id_editorial = dato;

end

call CONSULTA_EDITORIAL(1);


Usando los procedimientos permite facilitar de uso de sentencias.

Macros - Ensamblador

Programa que coloca el cursor en algun lugar en pantalla con macros e imprime un caracter.

gotoxy macro fila,col ;declaracion de macro con los parametros fila,col
mov ah,02h
mov dh,fila ;utiliza el parametro fila que es recibido al llamar el macro
mov dl,col  ;utiliza el parametro col que es recibido al llamar el macro
mov bh,0h
int 10h
endm     ;fin de macro
pantalla macro que ;declaracion de macro con el parametro llamado que
mov ah,02h
mov dl,que
int 21h
endm     ;fin de macro
.model small
.data
.code
startup:
mov ax,@data
mov ds,ax
mov ax,0003h
int 10h
gotoxy 10,10 ;llama macro gotoxy y envia los parametros 10,10 para fila y col
pantalla 41h ;llama macro pantalla el cual imprime un caracter en pantalla 41h es A
mov ah,01h
int 21h
mov ax,4c00h
int 21h
end startup

Programa que coloca un caracter en la posicion dada de acuerdo a parametros ingresados por teclado

TITLE Cadena que solicita una cadena y una posicion para mostrarla

gotoxy macro fila,col ;declaracion de macro gotoxy parametros:fila,col
mov ah,02h   ;complemento interrupcion 10h modo video colocacion cursor
mov dh,fila  ;coordenada x para colocacion de cursor dh
mov dl,col   ;coordenada y para colocacion de cursor dl
mov bh,0h 
int 10h      ;interrupcion de video
endm   ;fin de macro

pantalla macro que  ;declaracion de macro pantalla parametro que
mov ah,02h       ;complemento interrupcion 21h
mov dl,que   ;que es el caracter capturado
int 21h      ;interrupcion DOS
endm  ;fin de macro

imprime macro eztryng  ;declaracion de macro con parametro eztryng
mov dx,offset eztryng  ;coloca mensajes en dx
mov ah,9               ;complemento para la interrupcion 21h para impresion de txto
int 21h                ;interrupcion DOS
endm                   ;fin de macro

.data    ;variables
mensaje DB "INGRESE UN CARACTER: ","$"
mensaje2 DB "INGRESE X del 0 al 9: ","$"
mensaje3 DB "INGRESE Y del 0 al 9: ","$"
caracter DB 40
varx DB ?
vary DB ?
vtext db 100 dup('$')

.code

startup:
mov ax,@data  ;asignacion de datos ax
mov ds,ax     ;asignacion de datos al segmento de datos

imprime mensaje ;llama macro imprime con el parametro 'mensaje'
mov si,00h      ;limpia el apuntador SI


 leer:          ;declaracion de metodo leer 
 mov ax,0000    ;limpia ax
 mov ah,01h     ;complemento para interrupcion 21h captura
 int 21h        ;interrupcion DOS
 mov caracter[si],al ;guarda el dato capturado en variable caracter
 inc si         ;incrementa apuntador si
 cmp al,0dh     ;compara si la ultima tecla presionada fue Intro
 ja coordenadas ;si cumple brinca a coordenadas
 jb leer        ;sino cumple vuelve a ejecutar leer

coordenadas:    ;declaracion de metodo coordenadas
mov dx,offset caracter ;coloca en dx el caracter ingresado
mov ah,0ah             ;complemento de interrupcion 21h lee cadena de texto por teclado
int 21h                ;interrupcion DOS
imprime caracter       ;llama macro imprime con parametro caracter
mov ax,0003h           ;complemento interrupcion 10h modo texto
int 10h
imprime mensaje2       ;llama macro imprime con parametro mensaje2
mov ah,01h             ;complemento de interrupcion 21h Eco de un caracter
int 21h                ;interrupcion DOS
sub al,30h             ;resta 30h para convertir al valor numerico
mov bl,al              ;mueve al a bl
mov varx,al            ;guarda al en varx (coordenada x)
mov ax,0003h           ;complemento interrupcion 10h modo texto
int 10h
imprime mensaje3       ;//////////////se repite/////////
mov ah,01h
int 21h
sub al,30h
mov bl,al
mov vary,al            ;////////////////////////
mov ax,0003h           ;complemento interrupcion 10h modo texto
int 10h                ;interupccion de video

gotoxy vary,varx       ;llama macro gotxy con los parametros vary y varx como columna y fila
pantalla caracter[0]   ;llama macro pantalla con el caracter capturado como parametro

mov ah,01h             ;complemento de interrupcion 21h Eco de un caracter
int 21h                ;interrupcion DOS
mov ax,4c00h           ;complemento interrupcion 21h fin de probrama
int 21h                ;interrupcion DOS
end startup            ;fin de funcion principal

Documento Macros

http://atc2.aut.uah.es/~avicente/asignaturas/ects/pdf/lects_t5.pdf

http://atc2.aut.uah.es/~avicente/asignaturas/lec/pdf/pr6.pdf