Vaciar todos los registros de una tabla en mysql

Si queremos eliminar todos los registros de una tabla en MySql tenemos dos opciones, la primera es tan solo utilizar nuestra sentencia “DELETE” de siempre solo que sin ningún “WHERE”, haciendo que se borren todos los datos de la tabla:

DELETE FROM tabla

Pero también podemos optar por la alternativa que es mediante la declaración “TRUNCATE TABLE” de la siguiente forma

TRUNCATE TABLE tabla

Para empezar la opción con DELETE devuelve el número de registros que fueron borrados, mientras que TRUNCATE TABLE no devuelve nada.

Por otro lado TRUNCATE lo que hace en realidad es destruir la tabla y volverla a crear y no eliminar cada uno de los registros y puesto que eliminar y crear la tabla es mucho más rápido que eliminar todos los registros.

Otra diferencia importante tiene que ver con la misma característica de TRUNCATE TABLE de destruir y volver a crear la tabla, y es que reinicia todos los valores AUTO_INCREMENT de la tabla, es decir que si ibamos en el registro 1340, y usamos TRUNCATE TABLE al insertar un nuevo registro este volvería a ser el 1, mientras que en caso de usar DELETE FROM el AUTO_INCREMENT se conservaría intacto por lo que nuestro nuevo registro sería el número 1341 a pesar de ser el primero.

Reparar tablas InnoDB o MyISAM

Para reparar tables InnoDB en mysql necesitaremos ejecutar en nuestro cliente de MySQL las siguientes sentencias para repararlas:
CHECK TABLE nombre_tabla EXTENDED
Distintas opciones que podemos aplicar a CHECK TABLE:

  • QUICK
    No escanea los registros para chequear enlaces incorrectos.
  • FAST
    Sólo chequea tablas que no se han cerrado correctamente.
  • CHANGED
    Sólo las tablas chequeadas que se han cambiado desde el úlitmo chequeo o no se han cerrado correctamente.
  • MEDIUM
    Escanea registros para verificar que los enlaces borrados están bien. También calcula el checksum de la clave para los registros y lo verifica con el checksum calculado para las claves.
  • EXTENDED
    Realiza una búsqueda completa para todas las claves para cada registro. Se asegura que la tabla es consistente 100%, pero tarda mucho tiempo!

La cual nos devolvera el status actual de nuestra tabla.

Si nos da Error ejecutaremos:
REPAIR TABLE nombre_tabla

¿que son los archivos .dll?

Las .DLL son LIBRERIAS que contienen rutinas y funciones que utilizan los programas.

Las librerías se utilizan para evitar tener que escribir repetidamente en los ejecutables las mismas instrucciones.

Las librerías permiten, además, que el .EXE sea más pequeño y las rutinas solamente se cargan en memoria cuando son llamadas por el programa.

Después, con programas especiales, se las «compila» para que puedan funcionar.

Entonces se convierten a lenguaje binario que nadie va a poder entender.

La unica forma de verlas es con editores especiales pero, aún así, lo verás en hexadecimal.

Recorrer y modificar una Hashtable

El metodo mas rapido para recorrer la hastable y modificarla es el siguiente:

Dim tablaPrueba As New Hashtable

tablaPrueba.Add(11, "Madrid")
 tablaPrueba.Add(22, "Barcelona")
 tablaPrueba.Add(3, "Valencia")
 tablaPrueba.Add(44, "Bilbao")
 tablaPrueba.Add(57, "Sevilla")

' Se crea un Array de elementos DictionaryEntry con el tamaño dela tabla a recorrer
 Dim arrayCopia(tablaPrueba.Count - 1) As DictionaryEntry

' Se copia el contenido de la tabla sobre el array que acabamos de crear
 tablaPrueba.CopyTo(arrayCopia, 0)

' Se borra completamente la tabla inicial
 tablaPrueba.clear

' Se recorre el arrayCopia con un bucle For... Next a la vez que se añaden los nuevos elementos modificados a la tabla
 For i As Integer = 0 To arrayCopia.Length - 1
 tablaPrueba.Add(arrayCopia(i).Key, "España")
 Next

Inyeccíon de dependencia en asp.net

En el ámbito del desarrollo de software, siempre es bueno eliminar dependencias. En otros términos, bajar el nivel de acoplamiento.

Hay casos en que se logra más directamente y otros en que no es tan simple.

Para estos últimos contamos con un pattern llamado Dependency Injection,Inyección de Dependencia, término por primera vez usado por Martin Fowler. Si te interesa ir a la fuente, acá está su documento sobre Dependency Injection.

En este post voy a intentar explicar que viene a resolver este patrón y sus distintas implementaciones.

Cuando tenemos un objeto que necesita de otro para funcionar correctamente, tenemos definida una dependencia. Esta dependecia puede ser altamente acopladatight coupling, o levemente acopladaloose coupling. Si el acoplamiento es bajo el objeto independiente es fácilmente reemplazable, si, en cambio el acoplamiento es alto, el reemplazo no es fácil y se dificulta el diseño de tests unitarios.

Supongamos que tenemos una clase que define un producto, que necesita un componente, este componente puede provenir de distintos fabricantes, en general cubren las mismas funciones. Los productos son varios y alternativamente pueden valerse del componente de cualquier fabricante.

Si instanciamos uno de los componentes en forma directa necesitamos referenciarlo. Si el mercado nos exige cambiar de componente, tendríamos que eliminar la referencia anterior, crear la nueva, revisar si los métodos, funciones y propiedades son homogéneos, si no lo son, corregir el código donde sea necesario… Si a esto le agregamos que valdría la pena tener una versión con el primer componente y otra con el segundo, la situación empeora. Si hubiera cincuenta componentes alternativos, la situación ya sería inmanejable.

Acá es donde la necesidad del patrón Dependency Injection se hace evidente.

Supongamos que este conjunto de componentes ejecuta básicamente cuatro métodos, que son los que nosotros necesitamos: Initialize, Shutdown, Prepare y DoIt.

Entonces comencemos por escribir una interface que defina estos cuatro métodos:

[VB]

Public Interface ISomeHardware
Sub Initialization()
Sub Shutdown()
Sub Prepare()
Sub DoIt()
End Interface

[C#]

public interface ISomeHardware
{
void Initialization();
void Shutdown();
void Prepare();
void DoIt();
}

Las clases que definan los componentes deben implementar la interfaceISomeHardware. En nuestro ejemplo, ComponentA y ComponentB:

[VB]

Public Class ComponentA
Implements ISomeHardware
Public Sub InitializationBegin() ImplementsISomeHardware.Initialization

End Sub
Public Sub ShutdownBegin() Implements ISomeHardware.Shutdown

End Sub
Public Sub PrepareBegin() Implements ISomeHardware.Prepare

End Sub
Public Sub DoItBegin() Implements ISomeHardware.DoIt

End Sub
End Class

Public Class ComponentB
Implements ISomeHardware

Public Sub InitializationBegin() ImplementsISomeHardware.Initialization

End Sub
Public Sub ShutdownBegin() Implements ISomeHardware.Shutdown

End Sub
Public Sub PrepareBegin() Implements ISomeHardware.Prepare

End Sub
Public Sub DoItBegin() Implements ISomeHardware.DoIt

End Sub
End Class

[C#]

class ComponentA : ISomeHardware
{
public void Initialization() { }
public void Shutdown() { }
public void Prepare() { }
public void DoIt() { }
}

class ComponentB : ISomeHardware
{
public void Initialization() { }
public void Shutdown() { }
public void Prepare() { }
public void DoIt() { }
}

Aclaración: Acá hago una simplificación a efecto didáctico. Las clases que definen ComponentA y ComponentB, en realidad debieran ser wrappers de las dll’s provistas por los fabricantes. Para no complicar inútilmente las dejaré así.

Veremos tres implementaciones del patrón Dependency Injectionpor Constructorpor Setter por Interface.

POR CONSTRUCTOR:

Ahora voy a usar otro patrón llamado Facade o Fachada, la idea es encapsular todos los aspectos complejos de un subsistema de clases en una única y simple interface. En nuestro caso, ProductFacade:

[VB]

Public Class ProductFacade
Private SomeHardware As ISomeHardware
Public Sub New(ByVal pSomeHardware As ISomeHardware)
SomeHardware = pSomeHardware
End Sub
End Class

[C#]

public class ProductFacade
{
private ISomeHardware SomeHardware;
public ProductFacade(ISomeHardware SomeHardware)
{
this.SomeHardware = SomeHardware;
}
}

En esta clase se implementa la Inyección de Dependencia por medio delconstructor, que acepta un parámetro de entrada de tipo de interfaceISomeHardware. Este punto es determinante. Cualquier clase que implemente la interface ISomeHardware es aceptada como parámetro del constructor de ProductFacade. Este es todo el secreto.

Entonces, para inyectar la dependencia de un componente de un fabricante u otro por Constructor, se hace así:

[VB]

Dim ComponentA As ISomeHardware = New ComponentA
Dim Product01 As ProductFacade = New ProductFacade(ComponentA)
 
Dim ComponentB As ISomeHardware = New ComponentB
Dim Product02 As ProductFacade = New ProductFacade(ComponentB)

[C#]

ISomeHardware componentA = new ComponentA();
ProductFacade product01 = new ProductFacade(componentA);
 
ISomeHardware componentB = new ComponentB();
ProductFacade product02 = new ProductFacade(componentB);

Realmente elegante.

Para las siguientes dos implementaciones del patrón, usaremos la misma interface ISomeHardware y la definición de las clases ComponentA yComponentB.

Las variaciones estarán en la Fachada y en la Inyección de Dependencia.

POR SETTER:

En este caso la Inyección de Dependencia se efectiviza a través de unapropiedad definida en la Fachada.

[VB]

Public Class ProductFacade
Private mSomeHardware As ISomeHardware
 
Public Property SomeHardware() As ISomeHardware
Get
Return mSomeHardware
End Get
Set(ByVal value As ISomeHardware)
mSomeHardware = value
End Set
End Property
End Class

[C#]

public class ProductFacade
{
private ISomeHardware SomeHardware;
public ISomeHardware Component
{
get
{
return SomeHardware;
}
set
{
SomeHardware = value;
}

}

}

Para el caso de Setter, la Inyección de Dependencia queda determinada así:

[VB]

Dim ComponentA As ISomeHardware = New ComponentA
Dim Product01 As ProductFacade = New ProductFacade()
Product01.SomeHardware = ComponentA

Dim ComponentB As ISomeHardware = New ComponentB
Dim Product02 As ProductFacade = New ProductFacade()
Product02.SomeHardware = ComponentB

[C#]

ISomeHardware componentA = new ComponentA();
ProductFacade product01 = new ProductFacade();
product01.Component = componentA;
ISomeHardware componentB = new ComponentB();
ProductFacade product02 = new ProductFacade();
product02.Component = componentB; 

POR INTERFACE:

Ahora la Inyección de Dependencia está implementada sobre un métodoque acepta un parámetro de tipo de interface ISomeHardware.

[VB]

Public Class ProductFacade
Private mSomeHardware As ISomeHardware
Public Sub SetComponent(ByVal pSomeHardware As ISomeHardware)
mSomeHardware = pSomeHardware
End Sub
End Class

[C#]

public class ProductFacade
{
private ISomeHardware SomeHardware;
public void SetComponent(ISomeHardware SomeHardware)
{
this.SomeHardware = SomeHardware;
}
}

Cuando la Inyección de Dependencia es por Interface, se invoca de esta forma:

[VB]

Dim ComponentA As ISomeHardware = New ComponentA
Dim Product01 As ProductFacade = New ProductFacade()
Product01.SetComponent(ComponentA)
 
Dim ComponentB As ISomeHardware = New ComponentB
Dim Product02 As ProductFacade = New ProductFacade()
Product02.SetComponent(ComponentB)

[C#]

ISomeHardware componentA = new ComponentA();
ProductFacade product01 = new ProductFacade();
product01.SetComponent(componentA);
 
ISomeHardware componentB = new ComponentB();
ProductFacade product02 = new ProductFacade();
product02.SetComponent(componentB);

Las tres implementaciones difieren sutilmente entre si. La diferencia más importante que yo encuentro es que, Por Constructor, nos obliga a inyectar al crear la clase, mientras que las otras modalidades, la difieren para más adelante.

La diferencia entre estas dos últimas está en si se prefiere inyectar la dependencia en el set de una propiedad, Por Setter, o como argumento de un parámetro de entrada a un método o función, Por Interface. Cuestión de gusto sintáctico.

Códigos secretos para moviles Samsung

  • *#06# + llamar
    Ver el IMEI
  • *#0523# + llamar
    Ajustes de pantalla
  • *#9999# + llamar
    Versión de software
  • *#0837# + llamar
    Versión de software
  • *#0837# + llamar
    Versión de hardware
  • *#1234# + llamar
    Versión de hardware
  • *#2222# + llamar
    Versión H/W
  • *#0228# + llamar
    Información de la batería (capacidad, voltaje, temperatura)
  • *#0324#
    *#197328640#
    Menú técnico avanzado (Sin tarjeta SIM)
  • *#9125# + llamar
    Activa Smiley al cargar
  • *#0636# + llamar
    Estado de la memoria
  • *#0377# – *#0246# + llamar
    Información de la memoria
  • *#0746# + llamar
    Tamaño de la tarjeta SIM
  • *#0778# + llamar
    Mas información de la tarjeta SIM
  • *#0324# + llamar
    Monitor de red
  • *#0523# + llamar
    Ajustar el contraste de la pantalla LCD
  • *#0842# + llamar
    Prueba de la vibración
  • *#0636# + llamar
    Muestra capacidad de almacenamiento. En algunos modelos es necesario usar el código largo, para eso hay que anteponer el código: *#9998* o el *#8999* y quitar el primer cero del correspondiente. Por ejemplo, para obtener información de la batería funcionan los dos siguientes dependiendo del modelo: *#0228# *#9998*228#

NOTA: No nos hacemos responsables de la utilización o mal uso de estos códigos por parte del usuario.

¿Como evitar SQL Inyection en asp?

<%
Dim BlackList, ErrorPage, s

BlackList = Array(«–«, «;», «/*», «*/», «@@», «@»,_
«char», «nchar», «varchar», «nvarchar»,_
«alter», «begin», «cast», «create», «cursor»,_
«declare», «delete», «drop», «end», «exec»,_
«execute», «fetch», «insert», «kill», «open»,_
«select», «sys», «sysobjects», «syscolumns»,_
«table», «update»)

‘ Populate the error page you want to redirect to in case the check fails.
ErrorPage = «/ErrorPage.asp»

‘ This function does not check for encoded characters since we do not know the form of encoding your application uses. Add the appropriate logic to deal with encoded characters in here
»»»»»»»»»»»»»»»»»»»»»»»»»’
Function CheckStringForSQL(str)
On Error Resume Next

Dim lstr

‘ If the string is empty, return true
If ( IsEmpty(str) ) Then
CheckStringForSQL = false
Exit Function
ElseIf ( StrComp(str, «») = 0 ) Then
CheckStringForSQL = false
Exit Function
End If

lstr = LCase(str)

‘ Check if the string contains any patterns in our black list
For Each s in BlackList

If ( InStr (lstr, s) <> 0 ) Then
CheckStringForSQL = true
Exit Function
End If

Next

CheckStringForSQL = false

End Function

‘ Check forms data
For Each s in Request.Form
If ( CheckStringForSQL(Request.Form(s)) ) Then

‘ Redirect to an error page
Response.Redirect(ErrorPage)

End If
Next

‘ Check query string
For Each s in Request.QueryString
If ( CheckStringForSQL(Request.QueryString(s)) ) Then

‘ Redirect to error page
Response.Redirect(ErrorPage)

End If

Next

‘ Check cookies
For Each s in Request.Cookies
If ( CheckStringForSQL(Request.Cookies(s)) ) Then

‘ Redirect to error page
Response.Redirect(ErrorPage)

End If

Next
%>