Introducción a SQL

(En Construcción)

SQL

SQL es un descendiente de SEQUEL (o Structured English QUEry Language), originalmente diseñado por IBM. SQL fue creado como un lenguaje para construir sistemas de administración de base de datos relacionales (RDBMS: Relational DataBase Management System) sobre cualquier plataforma de hardware. El primer RDBMS comercial usando el SQL que apareció en 1981, y SQL es ahora el lenguaje estándar para consultas de red a través de plataformas de software y hardware diferentes. SQL es realmente un sublenguaje diseñado para estar embebido en un lenguaje de programación de una aplicación. Es tan flexible que puede ser usado tanto para manipulación de datos como para definición de datos.

Los servidores de bases de datos SQL manejan peticiones en unidades lógicas de trabajo llamadas transacciones. Una transacción es un grupo de operaciones relacionados que deben todas ser realizadas con éxito antes de que el RDBMS finalice cualquier cambio en la base de datos. El procesamiento de transacciones en servidores de bases de datos asegura que sus peticiones de procesamiento sean apropiados para el estado actual de sus datos. En SQL, todas las transacciones pueden ser terminadas explícitamente con un comando (instrucción) ya sea aceptar o descartar los cambios. Una vez usted esté satisfecho de que no hay errores ocurridos durante la transacción, puede terminar esa transacción con una instrucción de COMMIT. La base de datos entonces cambia para reflejar las operaciones que usted ha realizado. Si ocurre un error, usted puede abandonar los cambios con una intrucción de ROLLBACK.

El servidor de base de datos

Una red de área local (LAN: local area network) permite que sus usuarios compartan archivos, software, y recursos de impresora de las máquinas dedicadas llamadas servidores. Las estaciones de trabajo se conectan a los servidores de red a través de una red. En poblaciones grandes, dos o más LANs pueden conectarse a través de gateways para formar redes de área amplia (WAN: wide area networks). En un ambiente de red, su estación de trabajo usa el servidor de red de forma muy similar que usa su propio disco duro. Si su estación de trabajo necesita acceso a datos guardados en el disco duro del servidor hace una petición de esos datos del servidor. El servidor envía los datos solicitados a través de la red de vuelta a su estación de trabajo donde son procesados localmente. Sin embargo, el servidor de red difiere de la estación de trabajo en que los datos del servidor pueden ser accesados por más de un usuario al mismo tiempo.

Un servidor de base de datos es un servidor de red que procesa peticiones de bases de datos de alto nivel. Aunque otros tipos de servidores de red permiten que la mayoría del procesamiento ocurra en la estación de trabajo del usuario, los servidores de bases de datos son activos, con la mayoría del procesamiento realizándose en el servidor. Si su estación de trabajo necesita acceso a los datos guardados en un servidor de bases de datos, usted consulta al servidor directamente.

Convenciones de nombre (Naming conventions)

Esta sección describe las convenciones de nombre para tablas y columnas, mejoras de sintaxis, y limitaciones de sintaxis para SQL.

Las instrucciones en SQL están divididas en dos categorías diferentes, DDL (Data Definition Language) o de definición de datos y DML (Data Manipulation Language) o de manipulación de datos.

El SQL estándar de ANSI (ANSI-standard SQL) confina cada nombre de tabla o columna a una palabra simple formada de caracteres alfanuméricos y el símbolo de underscore (_).

El SQL tiene varias partes:

+ Lenguaje de definición de datos. (DDL)

El SQL DDL proporciona órdenes para definir esquemas de relación, eliminar relaciones, crear índices y modificar esquemas de relación.

+ Lenguaje de manipulación de datos interactivo.

El SQL DML incluye un lenguaje de consultas basado en el álgebra relacional y el cálculo relacional de tuplas. También incluye órdenes para insertar, suprimir y modificar tuplas de las bases de datos.

+ Lenguaje de manipulación de datos inmerso (DML)

La forma inmersa de SQL está diseñada para usar dentro de los lenguajes de programación.

+ Definición de vista.

El SQL DDL incluye órdenes para definir vistas.

+ Control de transacciones.

SQL incluye órdenes para especificar el comienzo y final de las transacciones.

Estructura básica

La estructura básica de una expresión en SQL consta de tres cláusulas: SELECT, FROM y WHERE.

+ La cláusula SELECT corresponde a la operación de proyección del álgebra relacional. Luego de SELECT usted debe listar los atributos que desea en el resultado de una consulta.

+ La cláusula FROM corresponde a la operación de producto cartesiano de álgebra relacional. Lista las relaciones que se van a examinar en la evaluación de la expresión.

+ La cláusula WHERE corresponde al predicado de selección del álgebra relacional. Consta de un predicado que implica atributos de las relaciones en la evaluación de la expresión.

SELECT [DISTINCT] column_list

FROM table_reference

[WHERE search_condition]

[ORDER BY order_list]

[GROUP BY group_list]

[HAVING having_condition]

[UNION select_expr]

SELECT

Una consulta típica en SQL tiene la forma:

SELECT A1, A2, A3,... An  

FROM r1, r2, .... rm  

WHERE P

Si se omite la cláusula WHERE el predicado P es verdadero. La lista de atributos puede sustituirse por un asterisco para seleccionar todos los atributos de todas las relaciones que aparecen la cláusula FROM.

SQL forma el producto cartesiano de las relaciones nombradas en la cláusula FROM, realiza una selección del álgebra relacional usando el predicado de la cláusula WHERE y después proyecta el resultado a los atributos de la cláusula SELECT.

El resultado de una consulta SQL es, por supuesto, una relación. Consideremos una consulta sencilla usando el ejemplo bancario. "Encontrar los nombres de las sucursales en la relación depósito":

SELECT nombre_sucursal  

FROM depósito

SELECT * FROM 'PARTS.DBF'  

SELECT * FROM "C:\SAMPLE\PARTS.DBF"

Operaciones de conjuntos y tuplas duplicadas

Los lenguajes de consulta formales se basan en la noción matemática de relación como un conjunto. Por ello nunca aparecen tuplas duplicadas en las relaciones. En la práctica, la eliminación de duplicados lleva bastante tiempo. Por tanto, SQL ( y casi todos los demás lenguajes de consulta comerciales) permiten duplicados en las relaciones. Así pues la consulta que veíamos con SELECT Y FROM muestra el nombre de sucursal por cada vez que aparezca en depósito.

En aquellos casos en los que queremos forzar la eliminación de duplicados, insertamos la palabra clave DISTINCT después de SELECT. Un ejemplo de una consulta así sería:

SELECT DISTINCT nombre-sucursal  

FROM depósito

Columnas

El SQL soporta nombres de columnas multi-palabra de Paradox y nombres de columna con las palabras clave de SQL duplicadas siempre que se encierren en comillas simples o dobles.

Por ejemplo, el siguiente nombre de la columna son dos palabras:

SELECT E."Emp Id" FROM EMPLOYEE E  

En el siguiente ejemplo, el nombre de la columna duplica la palabra clave DATE del SQL, por ello se especifica el nombre de la relación:

SELECT DATELOG."DATE" FROM DATELOG  

Cuando son dos columnas:

SELECT PART_NO, PART_NAME  

FROM PARTS

Cláusula FROM

La cláusula FROM especifica la tabla o tablas de las cuales se van a recuperar datos. Table_reference puede ser una tabla simple, una lista de tablas delimitada por comas, o puede ser un join interno o externo como se especifica en el estandar SQL-92. Por ejemplo, la siguiente instrucción especifica una tabla simple:

SELECT PART_NO            

FROM "PARTS.DBF"            

La siguiente instrucción especifica un join externo para table_reference:

SELECT * FROM PARTS LEFT OUTER JOIN INVENTORY            

ON PARTS.PART_NO = INVENTORY.PART_NO         

Operaciones de conjuntos

SQL incluye las operaciones UNION, INTERSECT, y MINUS, que operan sobre relaciones y corresponden a las operaciones del álgebra de conjuntos.

Vamos a demostrar cómo se pueden escribir en SQL las consultas de los siguientes ejemplos:

"Encontrar todos los clientes que tienen una cuenta en la sucursal Perryridge:

SELECT DISTINCT nombre-cliente  

FROM depósito  

WHERE nombre-sucursal = "Perryridge"

SELECT DISTINCT nombre-cliente  

FROM préstamo  

WHERE nombre-sucursal = "Perryridge"

(SELECT nombre-cliente  

FROM depósito  

WHERE nombre-sucursal = "Perryridge")  

UNION  

(SELECT nombre-cliente  

FROM préstamo  

WHERE nombre-sucursal = "Perryridge")

(SELECT DISTINCT nombre-cliente  

FROM depósito  

WHERE nombre-sucursal = "Perryridge")  

INTERSECT  

(SELECT DISTINCT nombre-cliente  

FROM préstamo  

WHERE nombre-sucursal = "Perryridge")

"Encontrar los clientes de la sucursal Perryridge que tienen una cuenta allí pero no un préstamo"

(SELECT DISTINCT nombre-cliente  

FROM depósito  

WHERE nombre-sucursal = "Perryridge")  

MINUS  

(SELECT DISTINCT nombre-cliente  

FROM préstamo  

WHERE nombre-sucursal = "Perryridge")

Cláusula WHERE

La cláusula WHERE opcional reduce el número de filas devuelto por una consulta a aquellos que cumplen con el criterio especificado en search_condition. Por ejemplo, la siguiente instrucción recupera sólo aquellas filas con PART_NO mayor a 543:

SELECT * FROM PARTS  

WHERE PART_NO > 543  

La cláusula WHERE puede incluir el predicado IN, seguido por una lista entre paréntesis de valores. Por ejemplo, la siguiente instrucción recupera sólo aquellas filas donde el número de parte se acopla a un item en la lista del predicado IN:

SELECT * FROM PARTS  

WHERE PART_NO IN (543, 544, 546, 547)  

Adicionalmente a operaciones de comparación escalares ( =, <, > ... ) también se pueden usar predicados adicionales que usan IN, ANY, ALL, EXISTS.

Predicados y Conectores

Para encontrar el nombre y la ciudad de todos los clientes que tienen un préstamo en alguna sucursal. En SQL se podría escribir así:

SELECT DISTINCT cliente.nombre-cliente, ciudad-cliente  

FROM préstamo, cliente  

WHERE préstamo.nombre-cliente = cliente.nombre-cliente

Ampliemos la consulta anterior y consideremos un caso algo más complicado en el que se requiere tamibén que todos los clientes tengan un préstamo en la sucursal Perryridge: "Encontrar el nombre y la ciudad de todos los clientes que tienen un préstamo en la sucursal Perryridge" para eso vamos a usar un AND.

SELECT DISTINCT cliente.nombre-cliente, ciudad-cliente  

FROM préstamo, cliente  

WHERE préstamo.nombre-cliente=cliente.nombre-cliente  

AND nombre-sucursal = "Perryridge"

SQL incluye un operador de comparacion BETWEEN para simplificar la cláusula WHERE. Si queremos encontrar el número de cuentas con saldos entre 90.000 y 100.000 dólares podemos usa la comparación siguiente:

SELECT número-cuenta  

FROM depósito  

WHERE saldo BETWEEN 90000 AND 100000

SQL también incluye un operador de selección para comparaciones de cadenas de caracteres. Los modelos se describen usando estas dos características especiales:

+ porcentaje (%) que es igual a cualquier subcadena.

+ subrayado _. El Carácter _ es igual a cualquier caracter.

Ejemplos:

+ "Perry%" es igual a cualquier subcadena que empiece por Perry.

+ "%idge%" es igual a cualquier cadena que contenga "idge" como subcadena.,

+ "___" es igual a cualquier cadena de 3 caracteres.

Los modelos de comparación en SQL se expresan usando el operador LIKE. "Encontrar los nombres de todos los clientes cuya calle incluye la subcadena 'Main'":

SELECT nombre-cliente  

FROM cliente  

WHERE calle LIKE "%Main%"

+ LIKE "ab\%cd%" ESCAPE "\" es igual a todas las cadenas que empiezan por "ab%cd".

Pertenencia a un conjunto

SQL se basa en un conjunto relacional de operaciones que permiten probar la pertenencia de las tuplas a una relación. El conector IN prueba si se es miembro de un conjunto, donde el conjunto es una colección de valores porducidos por una cláusula SELECT. El conecto NOT IN prueba la no pertenencia al conjunto. Para ilustrarlo, considérese de nuevo la consulta "Encontrar a todos los clientes que tienen un préstamo y una cuenta en el Perryridge". Vamos a hacer esto realizando una subconsulta.

SELECT DISTINCT nombre-cliente            

FROM préstamo 

WHERE nombre-sucursal= "Perryridge" AND 

nombre-cliente IN 

(SELECT nombre-cliente 

FROM depósito 

WHERE nombre-sucursal = "Perryridge")

SELECT DISTINCT nombre-cliente

FROM préstamo

WHERE nombre-sucursal = "Perryridge" AND

<nombre-sucursal, nombre-cliente> IN

(SELECT nombre-sucursal, nombre-cliente

FROM depósito)

SELECT DISTINCT nombre-cliente

FROM depósito

WHERE nombre-sucursal ="Perryridge" AND

nombre-cliente NOT IN

(SELECT nombre-cliente

FROM préstamo

WHERE nombre-sucursal = "Perryridge")

Variables de Tupla

SQL toma prestada la notación de variables de tupla dell cálcdiro relacional de tuplas. Una variable de tupla en SQL debe estar asociada con una relación determinada. Las variables de tupla se definen en la cláusula FROM. Para ilustrarlo, volvemos a escribir la consulta: "Encontrar el nombre y la ciudad de todos los clientes que tienen un préstamo en alguna sucursal", así:

SELECT DISTINCT T.nombre-cliente, ciudad cliente

FROM préstamo S, cliente T

WHERE S.nombre-cliente = T.nombre-cliente

En consultas que contienen subconsultas, se aplica una regla de ámbito a las variables de tupla. En una subconsulta, está permitido usar sólo variables de tupla definidas en la misma subconsulta o en cualquier consulta que contenga la subconsulta. Si una variable de tupla está definida tanto localmente en una subconsulta como globalmente en una consulta que la contiene, se aplica la definición local. Cuando escribimos expresiones de la forma nombre-relación.nombre-atributo, el nombre de la relación es, en efecto, una variable de tupla definida implícitamente.

Las variables de tuplas son muy útiles para comparar dos tuplas de la misma relación. En tales casos el álgebra relacional usa la operación renombrar. Supóngase que queremos encontrar todos los clientes que tienen una cuenta en la misma sucursal en la que Jones tiene una cuenta. Escribimos esta consulta:

SELECT DISTINCT T.nombre-cliente

FROM depósito S, depósito T

WHERE S.nombre-cliente = "Jones" AND

S.nombre-sucursal = T.nombre-sucursal

SELECT DISTINCT nombre-cliente FROM depósito

WHERE nombre-sucursal IN

(SELECT nombre-cliente FROM depósito

WHERE nombre-cliente = "Jones")

Comparación de conjuntos

Fue posible utilizar la construcción IN en la consulta anterior porque estuvimos probando la igualdad entre dos nombres de sucursales. Considérese la consulta: "Encontrar los nombres de todas las sucursales que tienen un activo mayor que alguna sucursal situada en Brooklyn". Podemos escribir la expresión:

SELECT DISTINCT nombre-cliente

FROM sucursal T, sucursal S

WHERE T.activo > S.activo AND

S.ciudad-sucursal = "Brooklyn"

SELECT nombre-sucursal FROM sucursal

WHERE activo > SOME

(SELECT activo

FROM sucursal

where ciudad-sucursal = "Brooklyn")

Considérese la consulta "Encontrar todos los clientes que tiene una cuenta en todas las sucursales situadas en Brooklyn". Para cada cliente, necesitamos ver si el conjunto de todas las sucursales en las que el cliente tiene una cuenta contiene el conjunto de todas las sucursales de Brooklyn.

SELECT DISTINCT S.nombre-cliente

FROM depósito S

WHERE (SELECT T.nombre-sucursal

FROM depósito T

WHERE S.nombre-cliente = T.nombre-cliente)

CONTAINS

(SELECT nombre-sucursal FROM sucursal

WHERE ciudad-sucursal = "Brooklyn")

Prueba de relaciones vacías

SQL incluye una característica para probar si una subconsulta tiene alguna tupla en su resultado. La construcción EXISTS devuelve el valor de verdadero si la subconsulta del argumento no está vacía. usando la construcción EXISTS, podemos escribir la consulta "Encontrar a todos los clientes que tienen una cuenta y un préstamo en la sucursal Perryridge".

SELECT nombre-cliente FROM CLIENTE

WHERE EXISTS( SELECT * FROM depósito

WHERE depósito.nombre-cliente =

cliente.nombre-cliente AND

nombre-sucursal = "Perryridge")

AND EXISTS (SELECT * FROM préstamo

WHERE préstamo.nombre-cliente=

cliente.nombre-cliente

AND nombre-sucursal= "Perryridge")

SELECT DISTINCT S.nombre-cliente FROM depósito S

WHERE NOT EXISTS ((SELECT nombre-sucursal FROM sucursal

WHERE ciudad-sucursal = "Brooklyn")

MINUS

(SELECT T.nombre-sucursal

FROM depósito T

WHERE

S.nombre-cliente=T.nombre-cliente))

Ordenación de la presentación de las tuplas

La cláusula ORDER BY especifica el orden de las filas recuperadas. Por ejemplo, la siguiente consulta recupera una lista de todas las partes listadas en orden alfabético por nombre de parte:

SELECT * FROM partes

ORDER BY nombre-parte ASC

SELECT * FROM PARTS

ORDER BY PART_NO DESC

SELECT DISTINCT nombre-cliente

FROM préstamo

WHERE nombre-sucursal = "Perryridge"

ORDER BY nombre-cliente

SELECT *

FROM préstamo

ORDER BY cantidad DESC, número-préstamo ASC

SELECT apellido || ', ' || primer-nombre

AS nombre-completo, teléfono

FROM clientes

ORDER BY nombre-completo ASC

Funciones de agregación

SQL ofrece la posibilidad de calcdirar funciones en grupos de tuplas usando la cláusula GROUP BY. El atributo o atributos dados en la cláusula GROUP BY se usan para formar grupos. Las tuplas con el mismo valor en todos los atributos en la cláusula GROUP BY se coloca en un grupo. SQL incluye también funciones de agregación:

SUM(), para totalizar valores numéricos en una columna

AVG(), para promediar todos los valores numéricos no Ndiros en una columna

MIN(), para determinar el valor mínimo en una columna

MAX(), para determinar el valor máximo en una columna

COUNT(), para contar el número de valores en una columan que cumplen con el criterio especificado

SELECT nombre-sucursal, AVG(saldo)

FROM depósito

GROUP BY nombre-sucursal

Se usa la cláusula DISTINCT por ejemplo en la siguiente consulta: "Encontrar el número de clientes con depósitos para cada sucursal"

SELECT nombre-sucursal, COUNT (DISTINCT, nombre-cliente)

FROM depósito

GROUP BY nombre-sucursal

Cláusula HAVING

La cláusula HAVING especifica condiciones que los registros deben cumplir para ser incluidos en el retorno de una consulta. Es una expresión condicional usada junto con la cláusula GROUP BY. Los Grupos que no cumplan con la expresión en la cláusula HAVING son omitidos del conjunto resultado.

Las subconsultas son soportadas en la cláusula HAVING. Una subconsulta trabaja como una condición de búsqueda para restringir el número de filas devueltas por la consulta externa, o "padre". Vea la cláusula WHERE adicionalmente a los operadores de comparación escalar ( =, <, > ... ) se pueden usar predicados adicionales usando IN, ANY, ALL, EXISTS.

A veces es útil declarar una condición que se aplica a los grupos más que a las tuplas. Por ejemplo, podríamos estar interesados únicamente en sucursales en las que el saldo promedio de las cuentas es mayor a 1200 dólares. Esta condición no se aplica a una única tupla.

Más bien se aplica a cada grupo construido mediante la cláusula GROUP BY. Para expresar una consulta de este tipo, usamo sl a cláusula HAVING. Los predicados de la cláusula HAVING se aplican después de la formación de grupos, por lo que pueden utilizarse funciones dke agregación.

SELECT nombre-sucursal, AVG (saldo)

FROM depósito

GROUP BY nombre-sucursal

HAVING AVG(saldo) > 1200

SELECT nombre-sucursal FROM depósito

GROUP BY nombre-sucursal

HAVING

AVG(saldo) >= ALL (SELECT AVG(saldo) FROM depósito

GROUP BY (nombre-sucursal)))

SELECT COUNT (*)

FROM cliente

cláusula UNION

La cláusula UNION combina los resultados de dos o más instrucciones SELECT para producir una tabla simple.

Joins heterogéneos

El SQL local soporta uniones o joins de tablas en diferentes formatos de bases de datos; tal como un join es llamado un "join heterogéneo". Cuando usted realiza un join heterogéneo, usted puede seleccionar un alias local.. Para seleccionar un alias, escoja SQL|Select Alias. Si usted no ha seleccionado un alias, SQL local intentará encontrar la tabla en el directorio actual de la base de datos que está siendo usado. Por ejemplo, el alias :WORK: podría ser el handle de base de datos pasado dentro de la función. Cuando usted especifica una tabla luego de selecciona un alias local:

Para tablas locales, especifique el alias o el path. para tablas remotas, especifique el alias.

Las siguientes instrucciones recuperan datos de una tabla de Paradox y una tabla de dBase:

SELECT DISTINCT C.CUST_NO, C.STATE, O.ORDER_NO

FROM "CUSTOMER.DB" C, "ORDER.DBF" O

WHERE C.CUST_NO = O.CUST_NO

Usted también puede usar alias BDE junto con los nombres de las tablas.

En SQL local, INSERT es de dos formas:

INSERT INTO CUSTOMER (FIRST_NAME, LAST_NAME, PHONE)

VALUES(:fname, :lname, :phone_no)

La insersión de una tabla a otra a través de una subconsulta no es permitida.

Ejemplos:

La siguiente instrucción añade una fila a una tabla, asignando valores a dos comlumnas:

INSERT INTO EMPLOYEE_PROJECT (EMP_NO, PROJ_ID)

VALUES (52, "DGPII");

La siguiente instrucción especifica valores para insertar dentro de una tabla con una instrucción de SELECT:

INSERT INTO PROJECTS

SELECT * FROM NEW_PROJECTS

WHERE NEW_PROJECTS.START_DATE > "6-JUN-1994";

UPDATE

No hay restricciones o extensiones de la instrucción UPDATE del ANSI-estandar.

DELETE

No hay restricciones o extensiones para la instrucción DELETE Ansi-estandar.

Las siguientes secciones describen funciones disponibles para instrucciones DML en SQL local.

Las substituciones de parámetros en instrucciones DML

Funciones agregadas

Funciones de String

Función DATE

Operadores

consultas Actualizables

Los marcadores de variables o parámetros (?) pueden ser usados en instrucciones DML en lugar de los valores. Las variables deben siempre estar precedidas por dos puntos (:), por ejemplo:

SELECT apellido, primer-nombre FROM "CUSTOMER.DB"

WHERE apellido > :var1 AND primer-nombre < :var2

Funciones de agregación

Se incluyen también expresiones agregadas complejas, tal como:

SUM( Field * 10 )

SUM( Field ) * 10

SUM( Field1 + Field2 )

El SQL local soporta las siguientes funciones de manipdiración de cadenas del SQL ANSI-standard para recuperación, insersión y actualización:

UPPER(), para forzar una cadena a estar en mayúscdiras

LOWER(), para forzar una cadena a estar en minúscdiras

TRIM(), para quitar repeticiones de un caracter especificado desde la izquierda, derecha o a ambos lados de una cadena

SUBSTRING() para crear una subcadena de una cadena

El SQL Local soporta la función EXTRACT() para aislar un campo numérico simple de un campo date/time al recuperar usando la siguiente sintaxis:

EXTRACT (extract_field FROM field_name)

Por ejemplo, la siguiente instrucción extrae el valor del año de un campo DATE:

SELECT EXTRACT(YEAR FROM HIRE_DATE)

FROM EMPLOYEE

Usted puede también extraer MONTH, DAY, HOUR, MINUTE, y SECOND usando esta función.

Nota: EXTRACT no soporta las cláusulas TIMEZONE_HOUR o TIMEZONE_MINUTE.

Operadores

El SQL Local soporta los siguientes operadores:

Tipo Operator

Aritméticos + - * /

Comparación < > = <> >= =<

IS NdirL IS NOTNdirL

Lógico AND OR NOT

Concatenación de cadenas ||

consultas actualizables

SQL Links ofrece soporte expandido para consultas actualizables de tabla simple y multi-tabla.

Estas restricciones se aplican a las actualizaciones:

Campos enlazadas no pueden ser actualizados

El cambio de índice causará un error

La semántica de consultas en vivo, para todos los métodos de manipdiración de datos, devuelve cursores que son funcional y semánticamente similares a los cursores retornados por la función DbiOpenTable del BDE. Las consultas de tablas simples o las vistas son actualizables, siempre que:

No hay operaciones JOIN, UNION, INTERSECT, o MINUS

No hay una palabra clave DISTINCT en el SELECT. (Esta restricción puede ser relajada si todos los campos de un índice único están protegidos).

Todo en la cláusula SELECT es una referencia de columna simple o un campo calcdirado, no se permiten agregaciones.

La tabla referenciada en la cláusula FROM es una tabla base actualizable o una vista actualizable.

No hay una cláusula de GROUP BY o HAVING.

No hay subconsultas que referencian la tabla en la cláusula FROM ni en subconsultas correlacionadas.

Cualquier cláusula ORDER BY puede ser satisfecha con un índice.

Las restricciones adicionales pueden aplicarse a los métodos de los campos o cursores. Si un índice es usado para satisfacer una cláusula de orden, la función DbiSwitchToIndex del BDE devuelve un error.

Restricciones a uniones en vivo

Las uniones en vivo dependen de los cursores compuestos. Los joins en vivo pueden usarse sólo si:

Todos All joins are left-to-right outer joins.

All join are equi-joins.

All join conditions are satisfied by indexes (for Paradox and dBASE)

Output ordering is not defined.

Each table in the join is a base table.

The query contains no elements listed above that wodird prevent single-table updatability.

Usted puede restringir cualquier consulta actualizable asignando la propiedad de la instrucción de consulta stmtCONSTRAINED a TRUE antes de ejecución. Un error será entonces retornado cada vez que una modificación o insersión cause que el nuevo registro desaparezca del conjunto resultado.

Campos calcdirados (Calcdirated fields)

Para consultas actualizables con campos calcdirados, una propiedad adicional de campo identifica un campo resultado como de sólo lectura y calcdirado. Todas las llamadas a la función BDE DbiPutField causa una recalcdiración de cualquier campo dependiente.

Llamadas de función BDE acerca de resultados de consultas

Si una consulta devuelve un cursor, ese cursor soportará completamente las capacidades de consulta de bajo nivel de un cursor devuelto de la función BDE DbiOpenTable. Por eso los filtros y los mapas de campo puede ser aplicado para refinar más el conjunto resultado. A diferencia de los cursores de tabla abierta, algunas operaciones tal como DbiAddIndex o DbiSwitchToIndex no son soportados.

Ejemplos DML

Las siguientes cláusulas son soportadas:

SELECT FROM, WHERE, ORDER BY, GROUP BY, and HAVING

Los siguientes agregados son soportados:

SUM, AVG, MIN, MAX, COUNT

Los siguientes operadores son soportados:

, -, *, /, =, < >, IS NdirL

Las operaciones UPDATE, INSERT, DELETE son soportados completamente. Los siguientes ejemplos muestras instrucciones DML con bases de datos estandar:

Ejemplo 1: UPDATE

update goods

set city = 'Santa Cruz'

where goods.city = 'Scotts Valley'

insert

into goods ( part_no, city )

values ( 'aa0094', 'San Jose' )

delete

from goods

where part_no = 'aa0093'

El siguiente ejemplo ilustra cómo se soportan las instrucciones SELECT como un equivalente de JOIN:

select distinct p.part_no, p.quantity, g.city

from parts p, goods g

where p.part_no = g.part_no

and p.quantity > 20

order by p.quantity, g.city, p.part_no

Ejemplo 5: Sub-selects

Se soportan las consultas sub-seleccionadas. El siguiente ejemplo ilustra esta sintaxis.

select p.part_no

from parts p

where p.quantity in

(select i.quantity

from inventory i

where i.part_no = 'aa9393')

Los siguentes ejemplos ilustran la cláusula GROUP BY:

select part_no, sum(quantity) as PQTY

from parts

group by part_no

Ejemplo 7: ORDER BY

El siguiente ejemplo ilustra el ORDER BY con una cláusula DESCENDING:

select distinct customer_no

from c:\data\customer

order by customer_no descending

Local SQL supports data definition language (DDL) for creating, altering, and dropping tables, and for creating and dropping indexes.

Views are supported.

Local SQL does not permit the substitution of variables for values in DDL statements.

The following DDL statements are supported:

CREATE TABLE

ALTER TABLE

DROP TABLE

CREATE INDEX

DROP INDEX

CREATE VIEW

For additional illustrative Ejemplos see:

DDL Ejemplos

CREATE TABLE

CREATE TABLE is supported with the following limitations:

Column definitions based on domains are not supported.

Constraints are limited to PRIMARY KEY for Paradox. Constraints are unsupported in dBASE.

For Ejemplo, the following statement creates a Paradox table with a PRIMARY KEY constraint on the LAST_NAME and FIRST_NAME columns:

CREATE TABLE "employee.db"

(

LAST_NAME CHAR(20),

FIRST_NAME CHAR(15),

SALARY NUMERIC(10,2),

DEPT_NO SMALLINT,

PRIMARY KEY(LAST_NAME, FIRST_NAME)

)

The same statement for a dBASE table shodird omit the PRIMARY KEY definition:

CREATE TABLE "employee.dbf"

(

LAST_NAME CHAR(20),

FIRST_NAME CHAR(15),

SALARY NUMERIC(10,2),

DEPT_NO SMALLINT

)

Creating Paradox and dBASE tables

You create a Paradox or dBASE table using local SQL by specifying the file extension when naming the table:

".DB" for Paradox tables

".DBF" for dBASE tables

If you omit the file extension for a local table name, the table created is the table type specified in the Defadirt Driver setting in the System page of the BDE Configuration Utility.

Data type mappings for CREATE TABLE

The following table lists SQL syntax for data types used with CREATE TABLE, and describes how those types are mapped to Paradox and dBASE types by the BDE:

SQL Syntax BDE Logical Paradox dBASE

SMALLINT fldINT16 Short Number (6,10)

INTEGER fldINT32 Long Integer Number (20,4)

DECIMAL(x,y) fldBCD BCD N/A

NUMERIC(x,y) fldFLOAT Number Number (x,y)

FLOAT(x,y) fldFLOAT Number Float (x,y)

CHARACTER(n) fldZSTRING Alpha Character

VARCHAR(n) fldZSTRING Alpha Character

DATE fldDATE Date Date

BOOLEAN fldBOOL Logical Logical

BLOB(n,1) fldstMEMO Memo Memo

BLOB(n,2) fldstBINARY Binary Binary

BLOB(n,3) fldstFMTMEMO Formatted memo N/A

BLOB(n,4) fldstOLEOBJ OLE OLE

BLOB(n,5) fldstGRAPHIC Graphic N/A

TIME fldTIME Time N/A

TIMESTAMP fldTIMESTAMP Timestamp N/A

MONEY fldFLOAT, fldstMONEY Money Number (20,4)

AUTOINC fldINT32, fldstAUTOINC Autoincrement N/A

BYTES(n) fldBYTES(n) Bytes N/A

x = precision (defadirt: specific to driver)

y = scale (defadirt: 0)

n = length in bytes (defadirt: 0)

1-5 = BLOB subtype (defadirt: 1)

ALTER TABLE

Local SQL supports the following subset of the ANSI-standard ALTER TABLE statement. You can add new columns to an existing table using this ALTER TABLE syntax:

ALTER TABLE table ADD column_name data_type [, ADD column_name data_type ...]

For Ejemplo, the following statement adds a column to a dBASE table:

ALTER TABLE "employee.dbf" ADD BUILDING_NO SMALLINT

You can delete existing columns from a table using the following ALTER TABLE syntax:

ALTER TABLE table DROP column_name [, DROP column_name ...]

For Ejemplo, the next statement drops two columns from a Paradox table:

ALTER TABLE "employee.db" DROP LAST_NAME, DROP FIRST_NAME

ADD and DROP operations can be combined in a single statement. For Ejemplo, the following statement drops two columns and adds one:

ALTER TABLE "employee.dbf" DROP LAST_NAME, DROP FIRST_NAME, ADD FdirL_NAME CHAR[30]

DROP TABLE

DROP TABLE deletes a Paradox or dBASE table. For Ejemplo, the following statement drops a Paradox table:

DROP TABLE "employee.db"

CREATE VIEW

A view creates a virtual table from a SELECT statement. You can look at just the data you need within this movable frame or window on the table, while the technical underpinnings are hidden. Instead of entering a complex qualified SELECT statement, the user simply selects a view.

CREATE VIEW describes a view of data based on one or more underlying tables in the database. The rows to return are defined by a SELECT statement that lists columns from the source tables. A view does not directly represent physically stored data. It is possible to perform select, project, join, and union operations on views as if they were tables.

CREATE VIEW enables users to create views on tables by using the following syntax:

CREATE VIEW view_name [ (column_name [, column_name]...)]

CREATE VIEW is supported in conjunction with the Client Data Repository (CDR). The CDR stores the SELECT statement that defines the view.

The "WITH CHECK OPTION" is supported to create a constrained view.

Views of Views are supported. However, the CASCADE/LOCAL view attribute is not supported, because all updateable views CASCADE the constraints.

DDL Ejemplos

The following Ejemplos show the use of DDL statements with standard databases.

Ejemplo 1a: DDL (DROP TABLE)

When the table name contains a period "." character, enclose the name in quotation marks:

drop table "c:\data\customer.db"

Ejemplo 1b: DDL (DROP TABLE)

No quotation marks are used if the table name does not contain the "." character:

drop table clients

Ejemplo 2: DDL (CREATE INDEX)

create index part on parts (part_no)

Paradox: Paradox primary indexes can be created only when creating the table. Secondary indexes are created as case insensitive and maintained, when possible.

dBASE: dBASE indexes are created as maintained. The Index name specified is the tag name.

For more information about different types of indexes, see DbiAddIndex in the Borland Database Engine Online Reference.

Ejemplo 3: DDL (DROP INDEX)

The syntax for drop index is tablename.indexname:

drop index parts.part_no

Paradox: For Paradox only, the syntax tablename.primary indicates the primary index:

drop index parts.primary

Introduction to Borland SQL Links for Windows (32-bit version)

Borland SQL Links for Windows is a set of BDE-hosted driver connections to database servers. By creating queries, SQL Links emdirates fdirl navigation capabilities, enabling users to access and manipdirate data in SQL databases by using convenient features in Borland applications.

Any Borland application based upon the Borland Database Engine (BDE) can use Borland SQL Links, including your custom applications built using the BDE API. Borland SQL Links is included with some Borland client/server application development tools such as Delphi Client/Server.

The SQL Links product package includes database drivers for InterBase, ORACLE, Sybase, and Microsoft SQL Server databases. These drivers require the installation of the appropriate vendor's server connectivity API or interface software. Borland Database Engine includes built-in drivers for Borland standard databases.

Other topics in this Introduction to SQL Links

Additional information

Other BDE online documentation

Local SQL Reserved Words.

[Local SQL Reserved Words.]

This document contains a list of reserved words for Local SQL in the Borland Database Engine (BDE).

This file contains an alphabetical list of words reserved by

Local SQL in the Borland Database Engine. Note that this file

is provided as-is.

ACTIVE, ADD, ALL, AFTER, ALTER, AND, ANY, AS, ASC, ASCENDING,

AT, AUTO, AUTOINC, AVG

BASE_NAME, BEFORE, BEGIN, BETWEEN, BLOB, BOOLEAN, BOTH, BY,

BYTES

CACHE, CAST, CHAR, CHARACTER, CHECK, CHECK_POINT_LENGTH,

COLLATE, COLUMN, COMMIT, COMMITTED, COMPUTED, CONDITIONAL,

CONSTRAINT, CONTAINING, COUNT, CREATE, CSTRING, CURRENT,

CURSOR

DATABASE, DATE, DAY, DEBUG, DEC, DECIMAL, DECLARE, DEFAdirT,

DELETE, DESC, DESCENDING, DISTINCT, DO, DOMAIN, DOUBLE, DROP

ELSE, END, ENTRY_POINT, ESCAPE, EXCEPTION, EXECUTE, EXISTS,

EXIT, EXTERNAL, EXTRACT

FILE, FILTER, FLOAT, FOR, FOREIGN, FROM, FdirL, FUNCTION

GDSCODE, GENERATOR, GEN_ID, GRANT, GROUP,

GROUP_COMMIT_WAIT_TIME

HAVING, HOUR

IF, IN, INT, INACTIVE, INDEX, INNER, INPUT_TYPE, INSERT,

INTEGER, INTO, IS, ISOLATION

JOIN

KEY

LONG, LENGTH, LOGFILE, LOWER, LEADING, LEFT, LEVEL, LIKE,

LOG_BUFFER_SIZE

MANUAL, MAX, MAXIMUM_SEGMENT, MERGE, MESSAGE, MIN, MINUTE,

MODdirE_NAME, MONEY, MONTH

NAMES, NATIONAL, NATURAL, NCHAR, NO, NOT, NdirL,

NUM_LOG_BUFFERS, NUMERIC

OF, ON, ONLY, OPTION, OR, ORDER, OUTER, OUTPUT_TYPE, OVERFLOW

PAGE_SIZE, PAGE, PAGES, PARAMETER, PASSWORD, PLAN, POSITION,

POST_EVENT, PRECISION, PROCEDURE, PROTECTED, PRIMARY,

PRIVILEGES

RAW_PARTITIONS, RDB$DB_KEY, READ, REAL, RECORD_VERSION,

REFERENCES, RESERV, RESERVING, RETAIN, RETURNING_VALUES,

RETURNS, REVOKE, RIGHT, ROLLBACK

SECOND, SEGMENT, SELECT, SET, SHARED, SHADOW, SCHEMA,

SINGdirAR, SIZE, SMALLINT, SNAPSHOT, SOME, SORT, SQLCODE,

STABILITY, STARTING, STARTS, STATISTICS, SUB_TYPE, SUBSTRING,

SUM, SUSPEND

TABLE, THEN, TIME, TIMESTAMP, TIMEZONE_HOUR, TIMEZONE_MINUTE,

TO, TRAILING, TRANSACTION, TRIGGER, TRIM

UNCOMMITTED, UNION, UNIQUE, UPDATE, UPPER, USER

VALUE, VALUES, VARCHAR, VARIABLE, VARYING, VIEW

WAIT, WHEN, WHERE, WHILE, WITH, WORK, WRITE

YEAR

OPERATORS:

||, -, *, /, <>, <, >, ,(comma), =, <=, >=, ~=, !=, ^=, (, )