w3schools - sql syntax
¿Qué trucos de codificación has usado para evitar escribir más sql? (11)
Esta pregunta fue sugerida por Kyralessa en el ¿Cuál es tu truco sql más útil para evitar escribir más sql ?. Tengo tantas buenas ideas para probar de la última pregunta, que estoy interesado en ver qué surge con esta pregunta.
Una vez más, no guardo la reputación de esta pregunta. Estoy esperando 7 días, para obtener respuestas, y luego marcarlo wiki. La reputación que la pregunta ha ganado se convierte en una recompensa por la pregunta.
Reglas de juego:
Si bien es razonable escribir código, mover el procesamiento de SQL al código para abordar problemas de rendimiento, ese no es realmente el objetivo de la pregunta. La pregunta no está limitada a problemas de rendimiento. El objetivo es menos simple sql para hacer el trabajo.
Comunique el concepto, para que otros usuarios digan "Oh, vaya, no sabía que pudieras hacer eso".
El código de ejemplo es muy útil para ayudar a las personas que son principalmente aprendices visuales.
Indique explícitamente qué idioma está utilizando y qué dialecto de SQL está utilizando.
Ponte en los zapatos de tus lectores. ¿Qué necesitarían ver allí mismo en la pantalla frente a ellos, que causará una epifanía. Su respuesta está ahí para beneficiar al lector. Escríbelo para ellos.
Los enlaces externos están bien, si aparecen después del ejemplo. Los enlaces externos como sustituto de una respuesta real no lo son.
Probablemente haya otras cosas para que sea más agradable para el lector que no haya pensado. Se creativo. Compartir conocimientos. Diviértete presumiendo.
[EDITAR] - Parece que no ha habido actividad en un tiempo. 5 votos = 50, entonces está la recompensa, y ha sido wikificado.
Donde trabajo, hemos hecho varias cosas para reducir el SQL y reducir la sobrecarga asociada al uso de SQL en Java. (Ejecutamos Java con MSSQL, MySQL y Oracle).
El truco más útil es usar el método setObject de Java para los parámetros de enlace. Esto, combinado con Varargs, le permite escribir un método de utilidad para ejecutar SQL:
DBUtil.execSQL(Connection con, String sql, Object... params)
Simplemente itere sobre los parámetros y use statement.setObject (index, param [index-1]). Para nulls usas setNull (). Hemos ampliado este concepto para consultas, con un método getResultSet; el objeto ResultSet envuelto también cierra su declaración, lo que facilita la gestión de recursos.
Para reducir el código SQL real escrito, tenemos un marco de creación de consultas que le permite especificar un grupo de columnas y sus tipos, y luego usar esto para especificar automáticamente criterios de búsqueda y columnas de salida. Podemos especificar fácilmente uniones y criterios de unión y esto maneja la mayoría de los casos normales. La ventaja es que puede generar un informe en aproximadamente 10 líneas de código, incluidos diferentes parámetros de consulta, clasificación, agrupación, etc. El código es demasiado complejo para incluirlo aquí.
También utilicé las tablas ALL_TABLES y ALL_TAB_COLUMNS de Oracle para generar sentencias SELECT; Otro truco que he usado es usar ResultSetMetadata para analizar la tabla:
ResultSet rs = DBUtil.getResultSet(con, "SELECT * FROM " + someTable);
ResultSetMetaData rsm = rs.getMetaData();
boolean first = true;
for (int i = 1; i <= rsm.getColumnCount(); i++) {
String col = rsm.getColumnName(i).toUpperCase();
// do something with the column name
}
Esto hace que sea fácil generar ciertos tipos de declaraciones; en este caso, tenemos una tabla activa y una tabla de archivo y estamos moviendo registros de una a la otra. Sin entrar en un debate sobre el uso de una tabla de archivos, el código de Java que he escrito me permite modificar las dos tablas sin tener que modificar el script de archivo.
Otro truco que usamos es usar constantes para todos nuestros nombres de tabla y columna. Esto hace que escribir SQL sea un poco tedioso, pero nos permite (entre otras cosas) generar SQL fácilmente para tablas con una construcción similar o idéntica. Como usamos constantes para definir los nombres de las columnas, el código realmente impone que las columnas idénticas tengan el mismo nombre. El uso de constantes también le permite buscar referencias a una columna en particular, lo que le permite examinar otras declaraciones SQL que pueden estar relacionadas con el trabajo que está realizando. Esto nos permite reutilizar SQL de otros módulos, en lugar de volver a escribir ciegamente la misma declaración de nuevo.
Idioma: C # / VB.NET.
Actualmente puedo escribir un sistema respaldado por DB sin escribir ningún SQL en absoluto. Mi DAL usa las definiciones de clase de POJO para generar SQL sobre la marcha. Ejemplo:
SearchCriteria sc = new SearchCriteria();
sc.AddBinding("Customer_id", "ALFKI");
List<Entity> customers = SQL.Read(sc, new Customers());
El código anterior devolverá una lista de instancias de clientes que coincidan con Customer_id a "ALFKI". El DAL se conecta al DB, crea el SQL, lo ejecuta, crea nuevos objetos, los completa y los envía de vuelta. Cuando haya terminado de cambiar los objetos, simplemente llame
SQL.Write(customer);
tener todos los elementos cambiados actualizados a la base de datos (db), téngalo en cuenta, solo los que cambiaron y solo las columnas que cambiaron.
Bono adicional: admite SQL Server, Oracle, Informix. El código del cliente nunca tiene que cambiar.
Si desea evitar escribir SQL, utilice un ORM como nHibernate, o una de las ofertas de Microsoft Linq para SQL / Entity Framework
Esto es incluso mejor que usar un generador, ya que no necesitará volver a ejecutar los generadores, y si usa Fluent nHibernate puede habilitar la Configuración a través de Convention y ni siquiera mantener un archivo / clase de mapeo.
He usado outlet-orm que es una asombrosa solución ORM que no genera. Creo que de todos los trucos que he hecho en el pasado, este ha sido el más conveniente y el ahorro de tiempo.
Recomiendo crear métodos compartidos que se centren en la tarea y usar elementos SQL simples, sin tener que escribir sql. Yo uso Subsonic para mi acceso de datos a MS SQL. Sin embargo, podría hacerlo no específico de la base de datos, como un DAL. Estos ejemplos se pueden personalizar a un ORM o como se acceda a los datos. Recomiendo crear una clase estática que se reduzca a una tarea específica.
Por ejemplo, si tiene una cuadrícula de datos para poblar y conoce una vista, tabla, proceso almacenado para poblarla, cree una función similar al siguiente código c #:
public static void BindDataGridViewWhere(DataGridView dgv, string tablename, string selectList, string whereClause)
{
Query qQuery = new Query(tablename);
qQuery.SelectList = selectList;
qQuery.WHERE(whereClause);
DataSet dsDGV = qQuery.ExecuteDataSet();
dgv.DataSource = dsDGV.Tables[0];
dgv.RowHeadersVisible = false;
}
Luego, en la página de inicio o algo así, simple llamada de 1 línea a este método pasando la vista de tabla de datos con la instrucción where, lo que desea que aparezca y cómo en la selección, y la cláusula where y está obligado.
BindDataGridViewWhere (dgvCars, "tbl_Cars", "CarName", "Color, mdl como modelo", "Color = ''azul''");
Esto funciona muy bien para cualquier objeto con el que trabajes mucho, como dropdownboxes, listboxes, datagridviews, cualquier otra cosa. Luego, para otros que no se ajustan a este modelo, tenga un método que simplemente devuelva un conjunto de datos. De esta manera, si necesita interactuar con él antes de mostrarlo, puede hacer una lógica comercial adicional, etc.
Me gusta este enfoque porque si desea cambiar los marcos de datos, tiene 1 lugar para realizar el cambio. Puedes construir una pantalla muy rápido de esta manera.
En uno de mis proyectos, uso un metamodelo (tablas, columnas, relaciones) que agrega información a las vistas sys * incorporadas.
Parte de los datos en mi metamodelo se usa para generar activadores de registro para inserción / actualización / eliminación, y para implementar eliminaciones en cascada en el lugar de eliminación de desencadenantes. Con aprox. 100 tablas el código generado para estos desencadenantes es de aproximadamente 12,000 líneas de código TSQL.
Un SP genera una estructura de datos de C # que compara el esquema de la base de datos en vivo con mi esquema de base de datos de desarrollo para asegurarse de que las actualizaciones funcionaron correctamente.
Recientemente, el metamodelo incluso me permitió generar código C # para la validación de eliminación (es decir, no puede eliminar el registro si existen registros dependientes) en formularios Asp.Net basados en FormView.
Lancé mi propio ORL (Object-Relational Mapper) en PHP para MySQL. Realmente simplifica todo lo que tiene que ver con el cambio de la base de datos, y funciona muy bien para situaciones simples.
Consiste en una clase base de la que puedes heredar. Lo subclases fácilmente:
<?php
class CSomething extends CDatabaseObject
{
}
// create a new Something
$oSomething = new CSomething();
$oSomething->somevariable = ''blah'';
$oSomething->Save();
// fetch an old Something by primary key
$oSomething = new CSomething(1);
// .. and delete it
$oSomething->Delete();
?>
Calcula automáticamente los índices en la tabla y la clave primaria. Si es necesario, puedes decirle a la clase estas cosas si hace algo malo.
Puede hacer búsquedas básicas especificando la cláusula WHERE del SQL (para que no sea completamente libre de SQL). Ya que habla sobre los tipos de datos de los campos, las consultas parametrizadas son simples.
Por supuesto, no puede hacer todo lo que necesito, pero ahorra mucho tiempo de desarrollo y código.
Recomiendo encarecidamente SQLAlchemy si es posible utilizar un entorno de python.
La otra cosa que probé es escribir mi propio generador de esquemas para probar nuestros sistemas en el trabajo. Esto fue más para generar diferentes combinaciones de consultas para intentar bloquear el sistema. Básicamente, definí un árbol de pseudo deparse, con diccionarios y listas
Aquí hay un fragmento de código
>>>for row in session.query(User, User.name).all():
... print row.User, row.name
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password FROM users []
<User(''ed'',''Ed Jones'', ''f8s7ccs'')> ed
<User(''wendy'',''Wendy Williams'', ''foobar'')> wendy
<User(''mary'',''Mary Contrary'', ''xxg527'')> mary
<User(''fred'',''Fred Flinstone'', ''blah'')> fred
El uso de funciones incorporadas de .NET, como Columnas de expresión (se muestra el ejemplo de VB) a datos, vincula varias columnas para que se muestren a la vez:
ds.Tables(0).Columns.Add(
New DataColumn("CustomDescription", GetType(String),
"LastName + '', '' + FirstName + '' - '' +
WorkEmail"))
ResultsListBox.DataSource = ds
ResultsListBox.DataTextField = "CustomDescription"
ResultsListBox.DataValueField = "EmployeeID"
ResultsListBox.DataBind()
No hay nada malo con SQL. Usa la herramienta correcta para el trabajo correcto.
Genere SP de SQL, Vistas, etc. a partir de los metadatos en INFORMATION_SCHEMA . Esa generación de código se puede aumentar con código personalizado.
Si varios SP hacen cosas similares, para facilitar un solo punto de mantenimiento, generaré SQL dinámico en su lugar.
Todo esto da como resultado menos código SQL y más código que se reutiliza y, por lo tanto, se prueba mejor, como cualquier biblioteca.
Aquí hay un ejemplo de generación de código para evitar escribir SQL