pgorm

func (*Connection) Close ¶

func (c *Connection) Close()

func (*Connection) GetContext ¶

func (c *Connection) GetContext() context.Context

func (*Connection) GetPool ¶

func (c *Connection) GetPool() *pgxpool.Pool

func (*Connection) New ¶

func (c *Connection) New(database string) *Connection

func (*Connection) Pool ¶

func (c *Connection) Pool() (*Connection, error)

func (*Connection) PoolMaster ¶

func (c *Connection) PoolMaster() (*Connection, error)

func (Date) Add ¶

func (d Date) Add(date time.Time, days int) time.Time

suma días a una fecha

func (Date) GetDate ¶

func (d Date) GetDate(date string, format FormatString) time.Time

*

• Retorna la fecha en tipo time
• @param {string} date: fecha en foprmato DD/MM/YYYY
• @return {time.Time} fecha en tipo time

func (Date) GetDateLocation ¶

func (d Date) GetDateLocation() time.Time

func (Date) GetDateLocationString ¶

func (d Date) GetDateLocationString() string

*

• Retorna Fecha en formato yyyy-mm-dd hh:mm:ss en zona horaria (America/Bogota)
• Return [string] : fecha formato string yyyy-mm-dd hh:mm:ss (America/Bogota)

func (Date) GetMonth ¶

func (d Date) GetMonth() int64

func (Date) GetYear ¶

func (d Date) GetYear() int64

retorna la fecha segun la locacion del usurio es este caso esta configurado para (America/Bogota) 2021-01-01 12:00:00.000

func (ManagerErrors) SqlConnections ¶

func (c ManagerErrors) SqlConnections(err error) error

func (ManagerErrors) SqlQuery ¶

func (c ManagerErrors) SqlQuery(err error) error

func (*Query) All ¶

func (q *Query) All() ([]map[string]interface{}, error)

All recupera todas las filas de resultados de la consulta SQL y las devuelve como una lista de mapas.

Esta función debe ser utilizada después de ejecutar una consulta con `Exec()`. Cada resultado se representa como un mapa, donde las claves son los nombres de las columnas y los valores son los valores correspondientes de esa fila.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1", "campo2").Where("campo3", "=", valor).Exec().All()

Devuelve:

• Una lista de mapas (`[]map[string]interface{}`), donde cada mapa representa una fila de resultados.
• Un error, si ocurre alguno durante el procesamiento de las filas.

func (*Query) And ¶

func (q *Query) And(and string, op OperatorWhere, arg interface{}) *Query

And añade una cláusula AND adicional a la cláusula WHERE existente de la consulta SQL.

Esta función permite agregar condiciones adicionales a la cláusula WHERE ya existente. Si no se ha definido una cláusula WHERE previa, no se realiza ninguna acción.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).And("campo4", ">", otroValor).Exec().All()

consultaFinal := queryBuilder.GetQuery()

Parámetros:

• and (string): Campo o expresión adicional para la condición.
• op (OperatorWhere): Operador lógico de comparación (por ejemplo: "=", "<>", ">", "<", "<=", ">=", "LIKE", "IN", etc.).
• arg (interface{}): Valor a comparar (puede ser simple o slice dependiendo del operador).

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) Close ¶

func (q *Query) Close()

Close libera los recursos asociados con la consulta SQL.

Esta función cierra el conjunto de resultados (`rowSql`) y la conexión (`conn`) asociada al struct Query. Debe ser llamada después de ejecutar una consulta para liberar correctamente los recursos y evitar fugas de memoria o conexiones abiertas.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("campo1").Exec()
defer queryBuilder.Close()

Importante:

• Si `rowSql` o `conn` no fueron inicializados o ya fueron cerrados, esta función podría generar un pánico. Se recomienda validar o asegurar su existencia antes de usar esta función si se usa fuera del flujo estándar.

No devuelve ningún valor.

func (*Query) Exec ¶

func (q *Query) Exec() *Query

Exec ejecuta la consulta SQL construida utilizando pgx y almacena los resultados en la estructura Query.

Esta función se encarga de ejecutar la consulta previamente construida con los métodos del builder (Select, Where, etc.), o mediante una consulta SQL personalizada con `SetQueryString`. Soporta consultas normales (`SELECT`) y procedimientos (`procedure`).

Si es una consulta `SELECT`, guarda los resultados (`pgx.Rows`) y los nombres de las columnas para su posterior lectura. Si es una ejecución (`INSERT`, `UPDATE`, `DELETE`, etc.) sin retorno de resultados, simplemente la ejecuta.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("id, name").Where("status", "=", "active").Exec()

Devuelve:

• Un puntero al struct Query actualizado, incluyendo los resultados o el error si ocurrió alguno.

func (*Query) ExecCtx ¶

func (q *Query) ExecCtx() *Query

ExecCtx ejecuta la consulta SQL construida utilizando `pgx` y almacena los resultados en la estructura `Query`.

A diferencia de otras variantes como `Exec`, esta función **no cierra la conexión con la base de datos**, permitiendo que se realicen múltiples consultas consecutivas sobre la misma conexión. Por esta razón, es responsabilidad del desarrollador cerrar la conexión manualmente mediante `pgorm.Query.Close()` cuando ya no se requiera.

Esta función ejecuta la consulta previamente construida mediante los métodos del builder (`Select`, `Where`, `SetTable`, etc.) o mediante una consulta SQL personalizada definida con `SetQueryString`. Soporta tanto consultas estándar (`SELECT`) como procedimientos (`CALL`, `PROCEDURE`).

- Si se trata de una consulta `SELECT`, almacena los resultados (`pgx.Rows`) en `q.rowSql` y los nombres de las columnas en `q.colSql`. - Si la consulta no retorna resultados (`INSERT`, `UPDATE`, `DELETE`, etc.), la ejecuta directamente y captura cualquier error.

Utiliza el contexto (`q.conn.context`) asociado a la conexión para soportar cancelación y timeout.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").
      Select("id, name").
      Where("status", "=", "active").
      ExecCtx()

Nota:

• La conexión **no se cierra automáticamente**. Debes cerrarla manualmente con `queryBuilder.Close()` cuando finalices el uso del objeto `Query`.

Retorna:

• Un puntero a `Query`, con los resultados cargados o el error ocurrido.

func (*Query) GetErrors ¶

func (q *Query) GetErrors() error

GetErrors devuelve el error almacenado durante la construcción o ejecución de la consulta SQL.

Esta función permite recuperar el error que se haya producido en alguna etapa del proceso de construcción, ejecución o procesamiento de la consulta SQL. Es útil para el manejo de errores encadenado, ya que muchas funciones devuelven el mismo struct `Query` y almacenan el error internamente.

Ejemplo de uso:

queryBuilder :=  new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("campo1").Where("campo2", "=", valor).Exec()
if err := queryBuilder.GetErrors(); err != nil {
    log.Println("Ocurrió un error:", err)
}

Devuelve:

• El error almacenado, si existe; de lo contrario, devuelve `nil`.

func (*Query) GroupBy ¶

func (q *Query) GroupBy(group ...string) *Query

GroupBy establece la cláusula GROUP BY de la consulta SQL. Se utiliza para agrupar los resultados de una consulta por uno o más campos especificados.

Esto es útil especialmente cuando se aplican funciones de agregación como COUNT, SUM, AVG, etc.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1", "COUNT(campo2)").GroupBy("campo1").Exec().All()
consultaFinal := queryBuilder.String()

Parámetros:

• group (...string): Lista de nombres de campos a utilizar en la cláusula GROUP BY.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) Join ¶

func (q *Query) Join(tp TypeJoin, table string, on string) *Query

Join añade una cláusula JOIN a la consulta SQL.

Permite establecer una relación entre la tabla principal y otra tabla especificando el tipo de unión (INNER, LEFT, RIGHT, FULL), la tabla a unir y la condición de emparejamiento (ON).

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("tabla_principal.columna1, tabla_secundaria.columna2").
	Join(pgorm.INNER, "tabla_secundaria", "tabla_principal.id = tabla_secundaria.id").
	Where("tabla_principal.columna3", "=", valor).Exec().All()

consultaFinal := queryBuilder.String()

Parámetros:

• tp (TypeJoin): Tipo de unión (TypeJoin). Puede ser pgorm.INNER, pgorm.LEFT, pgorm.RIGHT o pgorm.FULL.
• table (string): Nombre de la tabla a unir.
• on (string): Condición ON que define cómo se relacionan las tablas.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) Limit ¶

func (q *Query) Limit(limit ...int) *Query

Limit establece la cláusula LIMIT (y opcionalmente OFFSET) de la consulta SQL.

Esta función permite limitar la cantidad de resultados devueltos por la consulta y, si se desea, omitir un número determinado de registros iniciales (offset), útil para paginación.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})

// Limita la consulta a 10 filas
result, err := queryBuilder.SetTable("my_table").Select().Where("campo3", "=", valor).Limit(10).Exec().All()

// Limita la consulta a 10 filas, omitiendo las primeras 3
result, err := queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).Limit(10, 3).Exec().All()

consultaFinal := queryBuilder.String()

Parámetros:

• limit (...int): Lista de uno o dos enteros.
• Si se proporciona un solo entero, aplica solo el límite de filas.
• Si se proporcionan dos, el primero es el límite y el segundo el offset.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) New ¶

func (q *Query) New(config QConfig) *Query

func (*Query) One ¶

func (q *Query) One() (map[string]interface{}, error)

One recupera un solo resultado de la consulta SQL y lo devuelve como un mapa[string]interface{}.

Esta función se utiliza para leer una única fila del conjunto de resultados almacenado en `q.rowSql`, que debe haber sido previamente cargado mediante el método `Exec()`.

Devuelve un mapa donde: - Las claves son los nombres de las columnas devueltas por la consulta. - Los valores son los correspondientes valores de cada columna en la primera fila.

Si no hay filas o ocurre un error, se retorna un error o un mapa vacío.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).Exec().One()

Devuelve:

• Un `map[string]interface{}` con los datos de la primera fila del resultado.
• Un error, si no se encuentra una fila o ocurre algún problema al escanear los datos.

func (*Query) Or ¶

func (q *Query) Or(or string, op OperatorWhere, arg interface{}) *Query

Or añade una cláusula OR adicional a la cláusula WHERE existente de la consulta SQL.

Esta función permite agregar condiciones adicionales a la cláusula WHERE ya existente. Si no se ha definido una cláusula WHERE previa, no se realiza ninguna acción.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).Or("campo4", ">", otroValor).Exec().All()

consultaFinal := queryBuilder.GetQuery()

Parámetros:

• or (string): Campo o expresión adicional para la condición.
• op (OperatorWhere): Operador lógico de comparación (por ejemplo: "=", "<>", ">", "<", "<=", ">=", "LIKE", "IN", etc.).
• arg (interface{}): Valor a comparar (puede ser simple o slice dependiendo del operador).

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) OrderBy ¶

func (q *Query) OrderBy(campos ...string) *Query

OrderBy establece la cláusula ORDER BY de la consulta SQL. Permite ordenar los resultados de la consulta según uno o más campos especificados.

Cada campo puede ir acompañado de la dirección de ordenamiento (`ASC` o `DESC`).

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1", "campo2").Where("campo3", "=", valor).OrderBy("campo4 DESC", "campo5 ASC").Exec().All()
consultaFinal := queryBuilder.String()

Parámetros:

• campos(...string): Lista de nombres de columnas con o sin dirección de ordenamiento.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) Procedure ¶

func (q *Query) Procedure() error

Procedure ejecuta una consulta de tipo procedimiento (por ejemplo, `CALL` o funciones sin retorno de datos) utilizando `pgx`.

Esta función está diseñada para ejecutar procedimientos almacenados u operaciones SQL que **no devuelven resultados** (solo efectos colaterales en la base de datos).

Comportamiento: - Si existe un error anterior (`q.err`), lo retorna inmediatamente sin ejecutar la consulta. - Desactiva el indicador `sessionActiva`, indicando que no se espera continuar usando la misma conexión. - Ejecuta la consulta generada con `getQuery()` y los argumentos acumulados. - Si ocurre un error al ejecutar, se almacena y se retorna. - Siempre cierra la conexión (`q.conn.Close()`) al finalizar.

Ejemplo de uso:

query := new(pgorm.Query).New(pgorm.QConfig{Database: "my_db"})
query.SetQueryString("CALL procesar_datos($1)").SetArgs(123).Procedure()

Retorna:

• `nil` si la ejecución fue exitosa,
• Un `error` si la ejecución falló o si ya existía un error previo en el estado del `Query`.

func (*Query) ProcedureCtx ¶

func (q *Query) ProcedureCtx() error

ProcedureCtx ejecuta una consulta de tipo procedimiento (por ejemplo, `CALL` o funciones sin retorno de datos) utilizando `pgx`, manteniendo activa la sesión para continuar ejecutando más consultas sobre la misma conexión.

Esta función es útil cuando necesitas ejecutar procedimientos almacenados u operaciones SQL sin retorno de resultados, pero planeas seguir utilizando la conexión activa después de su ejecución.

A diferencia de `Procedure`, esta función **no cierra automáticamente la conexión** (`q.conn`), por lo que es responsabilidad del desarrollador cerrarla manualmente con `pgorm.Query.Close()` al finalizar el uso.

Comportamiento: - Si existe un error previo en el estado del `Query` (`q.err`), la función lo retorna inmediatamente. - Marca la sesión como activa (`q.sessionActiva = true`) para indicar que la conexión sigue disponible. - Ejecuta la consulta generada por `getQuery()` con los argumentos acumulados (`q.args`). - Si ocurre un error durante la ejecución, lo guarda en `q.err` y lo retorna.

Ejemplo de uso:

query := new(pgorm.Query).New(pgorm.QConfig{Database: "my_db"})
query.SetQueryString("CALL procesar_datos($1)").SetArgs(123).ProcedureCtx()
// ... puedes seguir usando query.conn mientras la sesión esté activa

Nota:

• La conexión **debe cerrarse manualmente** con `query.Close()` cuando ya no se necesite.

Retorna:

• `nil` si la ejecución fue exitosa,
• Un `error` si falló la ejecución o ya existía un error previo en la estructura.

func (*Query) ResetQuery ¶

func (q *Query) ResetQuery()

ResetQuery reinicia la configuración de la consulta SQL en el struct Query.

Esta función limpia todos los componentes relacionados con la construcción de la consulta SQL, como las cláusulas SELECT, WHERE, JOIN, etc., así como los argumentos asociados. Es útil cuando se desea reutilizar el mismo struct `Query` para construir una nueva consulta desde cero.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("campo1").Where("campo2", "=", valor).Exec()
queryBuilder.ResetQuery() // Limpia la consulta actual
queryBuilder.SetTable("my_table").Select("otro_campo").Where("otro_campo", "=", nuevoValor).Exec()

No devuelve ningún valor.

func (*Query) Select ¶

func (q *Query) Select(campos ...string) *Query

Select establece la cláusula SELECT de la consulta SQL. Puede especificar una lista de campos como argumentos. Si no se proporcionan campos, se seleccionan todos (*).

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select().Exec().All()
result, err := queryBuilder.SetTable("my_table").Select("campo1,campo2").Exec().All()
result, err := queryBuilder.SetTable("my_table").Select("campo1", "campo2").Exec().All()
consultaFinal := queryBuilder.String()

Parámetros:

• campos(...string): Lista de nombres de campos a seleccionar. Si está vacío, se seleccionan todos los campos.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) SetQueryString ¶

func (q *Query) SetQueryString(query string, arg ...interface{}) *Query

SetQueryString establece una consulta SQL completa y sus argumentos manualmente en el struct Query.

Esta función permite definir una sentencia SQL personalizada que no se construyó mediante los métodos de composición (como Select, Where, Join, etc.). Es útil cuando se desea ejecutar directamente una consulta específica con sus parámetros.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetQueryString("SELECT * FROM my_table WHERE email = $1", "[email protected]")

Parámetros:

• query (string): Cadena con la consulta SQL completa.
• arg (...interface{}): Argumentos de la consulta SQL, pueden ser uno o varios valores.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) SetTable ¶

func (q *Query) SetTable(table string) *Query

SetTable establece el nombre de la tabla que se utilizará en la consulta SQL.

Esta función define el nombre de la tabla principal sobre la cual se realizarán las operaciones SQL (SELECT, JOIN, WHERE, etc.). Es esencial establecer esta propiedad antes de construir la consulta.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("id", "nombre")

Parámetros:

• table (string): Nombre de la tabla como string.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) String ¶

func (q *Query) String() string

String devuelve la consulta SQL construida como una cadena.

Esta función implementa la interfaz `Stringer` para el struct Query, permitiendo que la consulta SQL construida se represente directamente como una cadena, por ejemplo al utilizar fmt.Println(q) o log.Print(q).

Devuelve:

• Una cadena (`string`) que representa la consulta SQL construida mediante los métodos del struct Query.

func (*Query) Text ¶

func (q *Query) Text(columna string) (interface{}, error)

Text recupera el valor de una columna específica de la primera fila de resultados de la consulta SQL.

Esta función es útil cuando se necesita obtener directamente un valor puntual de la primera fila, sin necesidad de recorrer todo el conjunto de resultados.

Debe ser llamada después de ejecutar la consulta con `Exec()`.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).Exec()
valor, err := queryBuilder.Text("nombreColumna")

Parámetros:

• columna (string): Nombre de la columna cuyo valor se desea recuperar.

Devuelve:

• El valor de la columna especificada (`interface{}`).
• Un error si no se encontró la columna, si no hay filas, o si ocurrió algún problema al leer el valor.

func (*Query) Top ¶

func (q *Query) Top(top int) *Query

Top establece la cláusula LIMIT de la consulta SQL para limitar el número de filas devueltas.

Esta función es útil cuando solo deseas recuperar una cantidad específica de registros, por ejemplo, para paginación o para obtener los primeros resultados de una tabla ordenada.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1", "campo2").Top(10).Exec().All()

consultaFinal := queryBuilder.String()

Parámetros:

• top (int): Número máximo de filas que se desean recuperar.

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (*Query) Where ¶

func (q *Query) Where(where string, op OperatorWhere, arg interface{}) *Query

Where establece la cláusula WHERE de la consulta SQL con una condición y un operador. La condición puede contener placeholders ($) para argumentos de la consulta. El operador se utiliza para comparar valores en la condición. El argumento es el valor que se comparará en la condición.

Ejemplo de uso:

queryBuilder := new(pgorm.Query).New(pgorm.QConfig{Database: "my_database"})
result, err := queryBuilder.SetTable("my_table").Select("campo1, campo2").Where("campo3", "=", valor).Exec().All()

consultaFinal := queryBuilder.String()

Parámetros:

• where (string): Campo o expresión de la condición a evaluar.
• op (OperatorWhere): Operador lógico o de comparación (por ejemplo: "=", "<>", ">", "<", "<=", ">=", "LIKE", "IN", etc.).
• arg (interface{}): Valor o valores con los que se compara (puede ser simple o slice dependiendo del operador).

Devuelve:

• Un puntero al struct Query actualizado para permitir el encadenamiento de métodos.

func (SchemaExe) GenerateSchema ¶

func (s SchemaExe) GenerateSchema(data any, action ActionType) []Fields

func (SchemaExe) GenerateSchemaFile ¶

func (s SchemaExe) GenerateSchemaFile(database string, table string)

func (*SqlExecMultiple) Commit ¶

func (sq *SqlExecMultiple) Commit() error

func (*SqlExecMultiple) Exec ¶

func (sq *SqlExecMultiple) Exec(params ...bool) error

* Ejecuta el query

Return
	- (error): retorna errores ocurridos durante la ejecución

func (*SqlExecMultiple) ExecTransaction ¶

func (sq *SqlExecMultiple) ExecTransaction(t *Transaction) error

func (*SqlExecMultiple) GetTransactions ¶

func (sq *SqlExecMultiple) GetTransactions() []*Transaction

GetTransaction retorna las transacciones ya procesadas.

Return
	- ([]*Transaction) retorna  []*Transaction

func (*SqlExecMultiple) New ¶

func (sq *SqlExecMultiple) New(database string) *SqlExecMultiple

Crea una nueva instancia de SqlExecMultiple con el nombre de la base de datos proporcionado.

Parámetros
  * name {string}: database
Return
  - (*SqlExecMultiple) retorna  puntero *SqlExecMultiple struct

func (*SqlExecMultiple) SetInfo ¶

func (sq *SqlExecMultiple) SetInfo(s Schema, datos ...map[string]interface{}) *Transaction

SetInfo establece la información para una nueva transacción en SqlExecMultiple.

Recibe un esquema (s Schema) y datos (datos ...map[string]interface{}) para la transacción.
Retorna un puntero a la transacción creada.
Parámetros
	* s {Schema}: esquema de la tabla
	* datos {[]map[string]interface{}}: datos a insertar, actualizar o eliminar
Return
	- (*Transaction) retorna puntero *Transaction

func (*SqlExecMultiple) SetSqlSingle ¶

func (sq *SqlExecMultiple) SetSqlSingle(s SqlExecSingle) (*Transaction, error)

SetSqlSingle establece la información de un SqlExecSingle para crear una nueva Transaction, los datos del .SqlExecSingle ya deben estar procesados listo para la ejecución.

Recibe SqlExecSingle (SqlExecSingle) listas  para  ser ejecutadas.
Retorna un puntero a la transacción creada o bien el error si es que existiera
Parámetros
	* s {...*Transaction}: array de transacciones ya procesadas, listas para su ejecución
Return
	- (*Transaction,) retorna puntero *Transaction, si existe algún error

func (*SqlExecMultiple) SetTransaction ¶

func (sq *SqlExecMultiple) SetTransaction(s ...*Transaction) ([]*Transaction, error)

SetTransaction establece la información para nuevas transacciones, recibiendo directamente nuevas transacciones ya procesadas.

Recibe uno o varias transacciones (s ...*Transaction) listas  para  ser ejecutadas.
Retorna un array de  punteros a la transacción creadas.
Parámetros
	* s {...*Transaction}: array de transacciones ya procesadas, listas para su ejecución
Return
	- ([]*Transaction) retorna  []*Transaction

func (*SqlExecSingle) Delete ¶

func (sq *SqlExecSingle) Delete() error

Valida los datos para Eliminar y crea el query para Eliminar

Return
	- (error): retorna errores ocurridos en la validación

func (*SqlExecSingle) Exec ¶

func (sq *SqlExecSingle) Exec(database string, params ...bool) error

Ejecuta el query

Return
	- returns {error}: retorna errores ocurridos durante la ejecución

func (*SqlExecSingle) GetData ¶

func (sq *SqlExecSingle) GetData() []map[string]interface{}

Retorna los datos que se enviaron o enviaran para ser insertados, modificados o eliminados

Return
	- []map[string]interface{}

func (*SqlExecSingle) Insert ¶

func (sq *SqlExecSingle) Insert() error

Valida los datos para insertar y crea el query para insertar

Return
	- (error): retorna errores ocurridos en la validación

func (*SqlExecSingle) New ¶

func (sq *SqlExecSingle) New(s Schema, datos ...map[string]interface{}) *SqlExecSingle

New crea una nueva instancia de SqlExecSingle con el esquema y los datos proporcionados.

Parámetros
	* s {Schema}: esquema de la tabla
	* datos {[]map[string]interface{}}: datos a insertar, actualizar o eliminar

Return
	- (*SqlExecSingle) retorna  puntero *SqlExecSingle struct

func (*SqlExecSingle) Update ¶

func (sq *SqlExecSingle) Update() error

Valida los datos para actualizar y crea el query para actualizar

Return
	- (error): retorna errores ocurridos en la validación

func (*Transaction) Delete ¶

func (t *Transaction) Delete() error

func (*Transaction) GetData ¶

func (t *Transaction) GetData() []map[string]interface{}

func (*Transaction) Insert ¶

func (t *Transaction) Insert() error

func (*Transaction) Update ¶

func (t *Transaction) Update() error