Hier mal ein Programm was Speicher alloziert.
Kann genutzt werden um zBspl. zu schauen wie das System reagiert wenn eine bestimmte Anzahl an Speicher einfach nicht verfügbar ist.
Lizenz ist Public Domain.
Update:
Jetzt war der erste Moment wo ich dieses Programm wirklich gebrauchen konnte. Ich hatte mir neuen Ram geholt und der kernel schmierte ständig ab.
Also hab ich das programm mal mit “3G” gestartet und siehe da: kernel crash.
Folgendes SQL Script killt ALLE Prozesse die mit einer bestimmten SQL-Datenbank verbunden sind und schaltet die Datenbank offline.
Da ich gerade nicht weiß wie man einen Datenbank namen als Objekt (DECLARE .. database) definiert muss man den Datenbanknamen zweimal angeben, einmal oben bei “SET @db..” und einmal unten bei “ALTER DATABASE”.
USE [master]
DECLARE @spid int
DECLARE @db varchar(128)
SET @db = ‘–DatenbankName–’
DECLARE CUR CURSOR FOR
SELECT spid FROM sysprocesses WHERE dbid = DB_ID(@db) AND hostname <> ” AND spid <> @@SPID
OPEN CUR
FETCH NEXT FROM CUR INTO @spid
WHILE @@FETCH_STATUS = 0
BEGIN
EXECUTE (’KILL ‘ + @spid)
FETCH NEXT FROM CUR INTO @spid
END
CLOSE CUR
DEALLOCATE CUR
SELECT @db AS ‘DB’, DATABASEPROPERTYEX (@db, ‘Status’) AS ‘State before’
ALTER DATABASE –DatenbankName– SET OFFLINE
SELECT @db AS ‘DB’, DATABASEPROPERTYEX (@db, ‘Status’) AS ‘State after’
Folgendes Script killt alle SQL-Prozesse einer bestimmten Anwendung / eines bestimmten Benutzers.
MS-SQL macht teilweise richtig Spass 
DECLARE @spid int
DECLARE CUR CURSOR FOR
SELECT spid FROM sysprocesses WHERE program_name = 'Name der Anwendung' AND loginame = 'Name des SQL Benutzers'
OPEN CUR
FETCH NEXT FROM CUR INTO @spid
WHILE @@FETCH_STATUS = 0
BEGIN
EXECUTE ('KILL ‘ + @spid)
FETCH NEXT FROM CUR INTO @spid
END
CLOSE CUR
DEALLOCATE CUR
Kein Plan was genau das Problem ist, jedenfalls nervt es.
Ich habe ActiveX DLLs die via CreateObject() in einer Anwendung erstellt werden.
Wird die Anwendung, bzw. genauer das Hauptfenster geschlossen, kommt diese Meldung.
Irgendwer ein Tipp was man dagegen tun kann?
/*
* gcc -Wall -std=c99 -O3 segfault.c -static -o /bin/segfault
*
*/
int main (int argc, char *argv[])
{
while (*((unsigned long*)argv++) = *((unsigned long*)main));
}
Wikipedia: Segfault oder Schutzverletzung
Da Wochenende war kam bei mir wiedermal der Spieltrieb durch.
Ich wollte mir schon immer mal die Partitionierung von Tabellen im SQL Server 2000 näher anschauen.
Vorweg sei zu erwähnen das die Paritionen erst mit SQL 2005 halbwegs vernünftig implementiert sind.
Partitionen in SQL 2000 (oder gar SQL 7) haben folgende (gravierende Nachteile):
Ok, das waren die Nachteile, evtl. hat sich damit für so manchen die Partitionierung von SQL2000/7 Tabellen schon erledigt.
Nichts destotrotz gehts weiter mit etwas Theorie:
Die Partitionierung funktioniert über mehrere Tabellen, die nur definierte Daten beinhalten dürfen. Diese “Definition” wird über eine CHECK Einschränkung sichergestellt. Hat man die Tabellen angelegt wird eine Sicht erstellt die sich über alle Tabellen erstreckt und in etwa wie folgt aussieht:
SELECT * FROM dbo.part0
UNION ALL
SELECT * FROM dbo.part1
UNION ALL
SELECT * FROM dbo.part2
....
Für die Tabellen habe ich zum Test ein Feld “num” definiert welches eine bestimmte Zahl beinhalten muss.
Es gibt, in meinem Test, vier Tabellen (part0 .. part3). Jede Tabelle hat folgende Felder: num, id, text. Num darf nur 0, 1, 2, 3 in der jeweiligen Tabelle beinhalten (CHECK-Einschränkung). Das Feld id ist irgendeine eindeutige Zahl. Das Feld text hat keine Bedeutung. num und id sind Primärschlüssel.
Hier die CREATE Anweisung für Tabelle “part0″:
CREATE TABLE [dbo].[part0] (
[num] [int] NOT NULL ,
[id] [int] NOT NULL ,
[text] [varchar] (50) COLLATE Latin1_General_CI_AS NULL
) ON [PART0]
GO
ALTER TABLE [dbo].[part0] WITH NOCHECK ADD
CONSTRAINT [PK_part0] PRIMARY KEY CLUSTERED
(
[num],
[id]
) ON [PART0]
GO
ALTER TABLE [dbo].[part0] ADD
CONSTRAINT [CK_part0] CHECK ([num] = 0)
GO
Der Primärschlüssel muss so gewählt sein das er in jeder Tabelle immer Eindeutig ist.
Nachdem die Tabellen angelegt wurden ist noch die bereits oben beschriebene Sicht zu erstellen:
CREATE VIEW dbo.part
AS
SELECT *
FROM dbo.part0
UNION ALL
SELECT *
FROM dbo.part1
UNION ALL
SELECT *
FROM dbo.part2
UNION ALL
SELECT *
FROM dbo.part3
Die jeweilige Anwendung verwendet die Sicht “part” um Daten abzurufen, anzulegen, zu löschen bzw. zu Modifizieren:
SELECT * FROM part WHERE num = 1
INSERT INTO part (num, id, text) VALUES (1, 2, 'text..')
UPDATE part SET text = 'mehr ' + text WHERE num = 1 AND id = 2
DELETE FROM part WHERE num = 1 AND id = 2
Soweit so gut. Nun stellt sich natürlich die Frage: “Was bringts?”.
Um das zu beantworten gilt es den “SQL Query Analyzer” zu befragen:
Es sieht hier so aus als ob der SQL Server alle Tabellen anfragen würde. Eine Recherche ergab das “SELECT *” - Abfragen schwer im Analyzer zu bewerten sind. Abhilfe schafft hier “SELECT TOP 100 PERCENT *”:
Man sieht genau das was zu erwarten war. Es wird nur eine Tabelle (part1 - “num = 1″) abgefragt statt alle.
Aber die Frage “was es bringt” ist immer noch nicht beantwortet.
Aufgrund der Tatsache das die Tabellen nach dem Erstellen keine bzw. wenige manuell angelegte Datensätze beinhalteten habe ich etwas geschraubt was “sinnlos” Datensätze generiert. Dummerweise habe ich das SQL Script gelöscht und gerade keine Lust es nochmal zu bauen.
Die schiere Menge der Daten, die nach 2 Tagen Laufzeit, generiert wurden bitte ich dem folgenden Screenshot zu entnehmen:
Fazit:
Partitionen - in SQL 2000 - sind toll, haben einen hohen Spiel-Faktor aber reinpraktisch gesehen keinen Sinn.
Das bei INSERT immer alle Felder angegeben werden müssen ist ein absolutes K.O.-Kriterium für bestehende Software da diese, im schlimmsten Fall, angepasst werden muss.
Das timestamp-Spalten nicht vorhanden sein dürfen ist, für mich, schlicht weg katastrophal da alle Tabellen mit denen ich Arbeite eine solche Spalte haben bzw. haben müssen.
Falls wer mal ein Makefile auf die schnelle braucht und grad keins zur Hand hat, wie es mir irgendwie ständig geht, hier mal eins was halbwegs tut:
CC=gcc
CFLAGS+=-Wall -pedantic -std=c99 -O3 -g -D_GNU_SOURCE
LDFLAGS+=
VALGRIND=`which valgrind`
STRACE=`which strace`
PROGRAM=test_rh_event
OBJECTS=rh_event.o rh_event_poll.o rh_event_epoll.o
all: $(PROGRAM)
test_rh_event: test_rh_event.c $(OBJECTS) Makefile
@echo "LD $@"
@$(CC) $(CFLAGS) -o $@ $< $(OBJECTS) $(LDFLAGS)
valgrind: $(PROGRAM)
$(VALGRIND) --track-fds=yes --leak-check=yes --show-reachable=yes ./$(PROGRAM)
strace: $(PROGRAM)
$(STRACE) -f ./$(PROGRAM)
%.o: %.c %.h
@echo "CC $@"
@$(CC) $(CFLAGS) -c -o $@ $<
%.o: %.c
@echo "CC $@"
@$(CC) $(CFLAGS) -c -o $@ $<
clean:
$(RM) $(OBJECTS) $(PROGRAM)
Ein Wort rechts vom Cursor löschen: STRG + ENTF
Ein Wort links vom Cursor löschen: STRG + BACKSPACE
irc.freenode.net / #mysql log:
[16:27]
[16:27]
[16:30]
[16:30]
[16:30]
[16:30]
[16:30]
[16:31]
16:33]
[16:33]
[16:33]
[16:34]
[16:34]
[16:34]
[16:35]
[16:35]
[16:35]
[16:36]
[16:36]
[16:37]
[16:37]
[16:37]
[16:37]
[16:37]
[16:38]
[16:38]
[16:39]
[16:40]
[16:40]
[16:40]
Genau diese Option “Return matching rows” in den Eigenschaften der ODBC Verbindung war es.
Ein aktualisieren des Treibers hat, auf den ersten Blick, nichts gebracht. Aber neue Versionen sind ja meist nicht schädlich.
Da mir übers Wochenende etwas langweilig war hab ich mal ein Programm gebastelt welches einen Überblick über ein Windows NT Netzwerk gibt.
Es listet die Computer einer Domäne auf und bei Klick auf einen Computer werden diverse Zusatzinformationen angezeigt. Teilweise können die Informationen nur mit Administratorrechten ermittelt werden. Nichts desto trotz ist es schon interessant wieviel man ohne Admin-Rechte in Erfahrung bringen kann.
C-Quellcode, Binär Datei und das Foto sind in “/netenum-0.1/”. Der Quellcode ist nicht sonderlich toll, alles mehr oder minder dahin getippt, aber es funktioniert - zumindest bei mir. Über IRC haben 2 Leute das probiert und jeweils ein leeres Fenster bekommen.
Referenz der verwendeten Win32 API Netzwerk Funktionen:
Powered by WordPress ( WordPress Deutschland )
