Michał Turecki - programming

SQL Server useful but less known features

Michał Turecki — Wed, 02 Nov 2016 11:43:56 +0000

Checking who is connected to the database

sp_who

SELECT NULL as [Connections by Database], [host_name] AS [Client Machine], db.name AS [Database], [program_name] AS [Client Program], COUNT(*) AS [Open Connections] FROM sys.dm_exec_sessions s (nolock) LEFT JOIN sys.dm_exec_requests r (nolock) ON r.session_id = s.session_id LEFT JOIN sys.databases db (nolock) ON db.database_id = r.database_id WHERE s.session_id >= 50 -- Ignore SQL Server processes GROUP BY [host_name], db.name, [program_name] ORDER BY [Client Machine], [Database], [Client Program]
Adjusting connection pooling settings

By default pool size is 100 per database with a command timeout (effectively a connection timeout) of 15 seconds. To increase add following to the connection string:

Connection Timeout=30;Pooling='true';Max Pool Size=200
Checking the size of column's contents

To check how much data the column contains:

SELECT *, DATALENGTH([column]) AS ColumnSizeInBytes FROM table
Using SQL Server profiler

Profiler is a powerful way to debug application performance problems, to check query execution time. If you're developing any application using SQL Server as a database, running it at least once for every application release can help with pinpointing possible performance issues. Remember the rule - there should be a constant number of queries regardless of the amount of records fetched - that way application will scale better. Sometimes it's better to replace a single complex query with more simpler queries because for each result row, columns shared by joins are repeated and delivered to client for processing many times.

programming

SQL

databases

sql-server

Online encode and decode base64, hex, url

Michał Turecki — Mon, 09 May 2016 08:19:08 +0000

On Protobuf.Net, using AsReference and multiple instances of object which should be deserialized only once.

Michał Turecki — Thu, 27 Nov 2014 14:13:47 +0000

There is a ProtoBuf.Net fact regarding using AsReference which somehow I missed when digging into why [ProtoAfterDeserialization] attribute is not applied for some objects.
The truth is that it is applied for some but not other objects even if I used AsReference attribute in some places. The AsReference attribute should be applied to ALL REFERENCES TO THE OBJECT, both collections and navigational properties, NOT JUST REFERENCES OTHER THAN THE REFERENCE WE CONSIDER MAIN ONE.

A simple test to prove it is below:

using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using NUnit.Framework;
using ProtoBuf;

namespace ProtoBufAsReferenceTest
{
    [ProtoContract]
    public class Office
    {
        public static int DeserializationCounter = 0;

        [ProtoMember(1)]
        public Collection<Computer> Computers { get; private set; }

        [ProtoMember(2)]
        public Collection<Person> People { get; private set; }

        public Office()
        {
            Computers = new Collection<Computer>();
            People = new Collection<Person>();
        }

        [ProtoAfterDeserialization]
        protected void OnDeserialize()
        {
            DeserializationCounter++;
            foreach(var computer in Computers)
            {
                computer.Office = this;
            }
            foreach(var person in People)
            {
                person.Office = this;
            }
        }
    }

    [ProtoContract]
    public class Computer
    {
        public static int DeserializationCounter = 0;

        [ProtoMember(1, AsReference = true)]
        public Person Person { get; set; }

        [ProtoIgnore]
        public Office Office { get; set; }

        [ProtoAfterDeserialization]
        protected void OnDeserialize()
        {
            DeserializationCounter++;
        }
    }

    [ProtoContract]
    public class Person
    {
        public static int DeserializationCounter = 0;

        [ProtoMember(1, AsReference = true)]
        public Computer Computer { get; set; }

        [ProtoIgnore]
        public Office Office { get; set; }

        [ProtoAfterDeserialization]
        protected void OnDeserialize()
        {
            DeserializationCounter++;
        }
    }

    [TestFixture]
    public class TestClasses
    {
        [Test]
        public void TestAsReference()
        {
            // 3 instances are created 1 of each type
            var office = new Office();
            var computer = new Computer();
            var developer = new Person();

            office.Computers.Add(computer);
            office.People.Add(developer);
            computer.Person = developer;
            developer.Computer = computer;

            using(var ms = new MemoryStream())
            {
                Serializer.NonGeneric.Serialize(ms, office);
                ms.Position = 0;
                Check(Serializer.Deserialize<Office>(ms));
            }
        }

        private void Check(Office office)
        {
            Assert.AreEqual(1, Office.DeserializationCounter);
            Assert.AreEqual(1, Person.DeserializationCounter); // fails - 2
            Assert.AreEqual(1, Computer.DeserializationCounter); // fails - 2
            var computer = office.People.First().Computer;
            Assert.IsNotNull(computer.Office); // fails - Office is null
        }
    }
}

Office class contains collections of Computers and Peoople without AsReference attribute. Person reference to the Computer for a change uses AsReference attribute. In the end 2 instances of Computer and 2 instances of Person are created.

Only change necessary to fix this problem is adding AsReference to the Office class collections:

        [ProtoMember(1, AsReference = true)]
        public Collection Computers { get; private set; }

        [ProtoMember(2, AsReference = true)]
        public Collection People { get; private set; }

I am not sure if this is common mistake people make when using ProtoBuf.Net but I suspect this might be the case as none of the questions on StackOverflow I've seen in the past mention this.
Or maybe it is only me who when using word "reference" thinks of references to the actual object which implies having at least a single copy of the actual object marked without "AsReference".
Bottom line is if you use AsReference, use it everywhere the object is referenced.

programming

protobuf

serialization

FlowDocument from a different thread - "The calling thread cannot access this object because a different thread owns it."

Michał Turecki — Mon, 07 Jul 2014 14:28:23 +0000

The FlowDocument along with most of the elements it contains inherits from DispatcherObject class. This means when constructed, it becomes linked to the thread in which it was constructed and causes several implications.

I'm sure such link was created for a reason - so that FlowDocument objects presented using WPF are not modified in a background thread as the updating is probably not implemented. I also won't debate on why objects contained in FlowDocument have no common, shared way of visiting them (IAddChild interface is helping with adding but something like IHaveChildren is not implemented).

Back to the topic - FlowDocument created by one thread cannot be used in another nor any of each one's inner objects. Or can't it?

One solution includes serializing a document in one thread and deserializing it in another (see this blog entry). This is a slow process as serialization is costly and serialization of a FlowDocument object with images and other graphical elements might not work at all unless XamlPackage format is used - and this one is even slower as requires ZIP compression/decompression.

Another is to create all FlowDocument objects on UI thread (see this SO article). Seems easy to do but what if there are thousand of objects which need to be added to a FlowDocument and at the same time user interface should stay responsive, even if it only needs to display a progress dialog ?

I found out another way to solve this problem, it is kind of hackish but seems to do the job for my needs:

public static void AttachToCurrentThread(this FlowDocument document)
{
	var dispatcher = Dispatcher.CurrentDispatcher;
	var field = typeof(DispatcherObject).GetField("_dispatcher", BindingFlags.NonPublic | BindingFlags.Instance);
	if(field == null)
	{
		throw new InvalidOperationException("_dispatcher property missing on DispatcherObject");
	}
	SetDispatcher(document, field, dispatcher, FlowDocumentVisitors);
}

private static readonly Func<object, object>[] FlowDocumentVisitors =
{
	x => (x is FlowDocument) ? ((FlowDocument) x).Blocks : null,
	x => (x is Section) ? ((Section) x).Blocks : null,
	x => (x is BlockUIContainer) ? ((BlockUIContainer) x).Child : null,
	x => (x is InlineUIContainer) ? ((InlineUIContainer) x).Child : null,
	x => (x is Span) ? ((Span) x).Inlines : null,
	x => (x is AnchoredBlock) ? ((AnchoredBlock) x).Blocks : null,
	x => (x is Paragraph) ? ((Paragraph) x).Inlines : null,
	x => (x is Table) ? ((Table) x).RowGroups : null,
	x => (x is Table) ? ((Table) x).Columns : null,
	x => (x is Table) ? ((Table) x).RowGroups.SelectMany(rg => rg.Rows) : null,
	x => (x is Table) ? ((Table) x).RowGroups.SelectMany(rg => rg.Rows).SelectMany(r => r.Cells) : null,
	x => (x is TableCell) ? ((TableCell) x).Blocks : null,
	x => (x is TableCell) ? ((TableCell) x).BorderBrush : null,
	x => (x is List) ? ((List) x).ListItems : null,
	x => (x is ListItem) ? ((ListItem) x).Blocks : null
};
	
private static void SetDispatcher(object item, FieldInfo field, object value, params Func<object, object>[] selectors)
{
	if(item is DispatcherObject)
	{
		var currentDispatcher = field.GetValue(item);
		if(currentDispatcher != null && currentDispatcher != value)
		{
			field.SetValue(item, value);
		}
	}
	if(item is IEnumerable)
	{
		foreach(var subItem in item as IEnumerable)
		{
			SetProperty(subItem, field, value, selectors);
		}
	}
	if(selectors != null)
	{
		foreach(var selector in selectors.Select(x => x(item)).Where(x => x != null))
		{
			SetProperty(selector, field, value, selectors);
		}
	}
}

Basically it just traverses FlowDocument and it's objects searching for DependencyObject instances and using reflection updates the _dispatcher private variable. This variable name can change in the future, the FlowDocument structure also can change so this solution can be considered not elegant or not stable but having said that DispatcherObject didn't change since .Net 3.5 and AttachToCurrentThread function can be easily adapted to handle different types of FlowDocument blocks and it's inner objects when those inherit from DispatcherObject.

If you are just reading this paragraph then feel free to leave some feedback, especially if I missed any important collections of DispatcherObject instances in the selectors array.

Update:

The previous code was expecting an IEnumerable as input and while this is fine and optimal (less calls) but not flexible enough to handle special cases well.
Unfortunately loading of a packed FlowDocument object, saved using XamlPackage format will fail on a non-STA thread ("The calling thread must be STA, because many UI components require this" exception thrown when TextRange.Load is called on a non-UI thread). This is a show-stopper for me so I can't use the code above anymore but it might become handy for someone not using Images.
I also updated it to support tables and lists and commented out style handling which I did not need (Styles are usually not tied to a thread anyway).
Actually the code can be generalized to handle any object, just change AttachToCurrentThread document argument type to object.

Update 2:
Some cosmetic changes and added a couple additional FlowDocument elements in a visitor.

flowdocument

programming

Delphi 2007 - error running on 64-bit Windows

Michał Turecki — Wed, 03 Apr 2013 08:40:53 +0000

Delphi 2007 is not new although it is the last non-unicode release of Delphi hence it is used frequently to maintain legacy code base.

And it has bugs. Some of them can be fixed by VCLFixPack and affect only compiled binaries.

Some are related to IDE and neither CnPack nor GExperts IDE extensions can fix them.

One of such bugs is related to debugging on 64-bit Windows. The problem is that after debugging session has ended, following error appears:

Assertion failure: "(!"SetThreadContext failed")" 
in ..\win32src\thread32.cpp at line 412 
Continue execution?

The error was thrown by bordbk105N.dll and it was discussed here (1) and here (2).

Unfortunately in (1) original URL has changed and (2) download links are dead so I attached a fix below as there's never enough of mirroring of the Internet. The executable is a patch tool which needs to be started as Administrator. It will modify bordbk105N.dll and fix the problem.

Attachment	Size
Delphi_2007_2009_WOW64_Debugger_Fix.exe	176 KB

TortoiseMerge with better shortcuts, like WinMerge

Michał Turecki — Fri, 18 Jan 2013 12:58:52 +0000

TortoiseMerge is a useful 3-way merge tool yet it lacks proper keyboard shortcuts configuration and default shortcuts seem to be designed only for basketball players, with fingers stretched from arrow keys up to function keys.
Update: Current Version of TortoiseMerge included in TortoiseGit has the keyboard shortcuts fixed and easy to use

Fortunately it is open source. Moreover, it uses standard accelerators embedded as resources in the executable so it can be easily modified to fit our needs using only a resource editor. I used ResourceHacker ( ResHack.exe ) and modified these while preserving existing shortcuts.

Shortcuts are located in Accelerators -> 100 -> 1033 path.

100 ACCELERATORS
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
{
	VK_Q, 57665, NOINVERT, CONTROL, VIRTKEY
	VK_ESCAPE, 57665, NOINVERT, VIRTKEY
	VK_DOWN, 32831, NOINVERT, VIRTKEY
	VK_DOWN, 32831, NOINVERT, SHIFT, VIRTKEY
	VK_LEFT, 32829, NOINVERT, VIRTKEY
	VK_LEFT, 32829, NOINVERT, SHIFT, VIRTKEY
	VK_RIGHT, 32830, NOINVERT, VIRTKEY
	VK_RIGHT, 32830, NOINVERT, SHIFT, VIRTKEY
	VK_UP, 32832, NOINVERT, VIRTKEY
	VK_UP, 32832, NOINVERT, SHIFT, VIRTKEY
	VK_LEFT, 32833, NOINVERT, CONTROL, VIRTKEY
	VK_LEFT, 32833, NOINVERT, CONTROL, SHIFT, VIRTKEY
	VK_RIGHT, 32834, NOINVERT, CONTROL, VIRTKEY
	VK_RIGHT, 32834, NOINVERT, CONTROL, SHIFT, VIRTKEY
	VK_F1, 57669, NOINVERT, SHIFT, VIRTKEY
	VK_C, 57634, NOINVERT, CONTROL, VIRTKEY
	VK_X, 57635, NOINVERT, CONTROL, VIRTKEY
	VK_F, 57636, NOINVERT, CONTROL, VIRTKEY
	VK_F3, 32790, NOINVERT, VIRTKEY
	VK_F3, 32818, NOINVERT, SHIFT, VIRTKEY
	VK_G, 32884, CONTROL, VIRTKEY
	VK_V, 57637, NOINVERT, CONTROL, VIRTKEY
	VK_INSERT, 57637, NOINVERT, SHIFT, VIRTKEY
	VK_BACK, 57643, NOINVERT, ALT, VIRTKEY
	VK_Z, 57643, NOINVERT, CONTROL, VIRTKEY
	VK_RIGHT, 32855, NOINVERT, ALT, CONTROL, VIRTKEY
	VK_RIGHT, 32857, NOINVERT, ALT, CONTROL, SHIFT, VIRTKEY
	VK_LEFT, 32859, NOINVERT, ALT, CONTROL, SHIFT, VIRTKEY
	VK_RIGHT, 32822, NOINVERT, ALT, SHIFT, VIRTKEY
	VK_RIGHT, 32820, NOINVERT, ALT, VIRTKEY
	VK_LEFT, 32819, NOINVERT, ALT, VIRTKEY
	VK_LEFT, 32821, NOINVERT, ALT, SHIFT, VIRTKEY
	VK_UP, 32780, NOINVERT, ALT, VIRTKEY
	VK_DOWN, 32779, NOINVERT, ALT, VIRTKEY
	VK_UP, 32802, NOINVERT, ALT, SHIFT, VIRTKEY
	VK_DOWN, 32804, NOINVERT, ALT, SHIFT, VIRTKEY
	VK_S, 32808, NOINVERT, ALT, VIRTKEY
	VK_F10, 32822, NOINVERT, CONTROL, SHIFT, VIRTKEY
	VK_F10, 32820, NOINVERT, CONTROL, VIRTKEY
	VK_F9, 32819, NOINVERT, CONTROL, VIRTKEY
	VK_F9, 32821, NOINVERT, CONTROL, SHIFT, VIRTKEY
	VK_O, 57601, NOINVERT, CONTROL, VIRTKEY
	VK_R, 32794, NOINVERT, CONTROL, VIRTKEY
	VK_F5, 32794, NOINVERT, VIRTKEY
	VK_S, 57603, NOINVERT, CONTROL, VIRTKEY
	VK_S, 57604, NOINVERT, CONTROL, SHIFT, VIRTKEY
	VK_F1, 57670, NOINVERT, VIRTKEY
	VK_F8, 32804, NOINVERT, VIRTKEY
	VK_F11, 32779, NOINVERT, VIRTKEY
	VK_F7, 32779, NOINVERT, VIRTKEY
	VK_F8, 32802, NOINVERT, SHIFT, VIRTKEY
	VK_F11, 32780, NOINVERT, CONTROL, VIRTKEY
	VK_UP, 32780, NOINVERT, CONTROL, VIRTKEY
	VK_DOWN, 32779, NOINVERT, CONTROL, VIRTKEY
	VK_F11, 32780, NOINVERT, SHIFT, VIRTKEY
	VK_F7, 32780, NOINVERT, SHIFT, VIRTKEY
	VK_F6, 57680, NOINVERT, VIRTKEY
	VK_F6, 57681, NOINVERT, SHIFT, VIRTKEY
	VK_D, 32775, NOINVERT, CONTROL, VIRTKEY
	VK_T, 32774, NOINVERT, CONTROL, VIRTKEY
	VK_INSERT, 57634, NOINVERT, CONTROL, VIRTKEY
	VK_DELETE, 57635, NOINVERT, SHIFT, VIRTKEY
	VK_INSERT, 57637, NOINVERT, SHIFT, VIRTKEY
	VK_A, 32883, NOINVERT, CONTROL, VIRTKEY
}

If you are too lazy to change the resources, you can download attached TortoiseMerge.exe v1.7.15.0 and use it with recent versions of TortoiseGIT/SVN.

Attachment	Size
TortoiseMerge.exe	1.65 MB

Simple themed TCheckComboBox control for Delphi - TComboBox with checkboxes

Michał Turecki — Wed, 12 Dec 2012 10:52:02 +0000

Recently I needed to upgrade a piece of software to do some things easily done in modern user interface libraries say WPF or FireMonkey (which I don't use personally), but requiring more effort to implement in Delphi VCL.

The task in question was to add a drop down menu with TCheckBox controls to a TStringGrid. This has been done countless times and TCheckedComboBox, TCheckBoxComboBox and others alike can be found on the Internet easily. The problem is none have the features I needed:

- separate Items and Values where Values can optionally be presented to a user instead of Items
- custom aggregation of values depending on user selection - checking checkboxes should trigger the event which will return a text calculated based on selections and custom algorithm, which can be say: sum all values of selected items, take maximum, average etc.
- optionally for ease of use, it should contain bitmask aggregation mode - where value can be set and retrieved by simply assigning to a string representation of integer and appropriate checked items will be translated to bit weights of items
- checks should be completely optional, when checks are disabled, the control should behave exactly like a normal TComboBox
- checks need to use windows themes and look alike all other checkboxes
- it should be as simple as possible but not any simpler - no copy + paste from Controls.pas or StdCtrls.pas

The control may have some bugs as it was not heavily tested and for best experience depends on some settings in DFM:

AutoComplete = False
Style = csDropDownList

Having said that, for all those who seek a free TCheckComboBox which have all or some of aforementioned features, feel free to use it.

The component is available to download from https://github.com/t00/deltoo#tcheckcombobox .

programming

delphi

Kalkulator wygranych amino lotto 2009 oraz 2010

Michał Turecki — Sat, 29 Aug 2009 09:44:58 +0000

Do końca roku Amino przygotowało ciekawą loterię - mozna wygrać wielokrotność 1000 złotych, ale nie więcej niż 10000 zł zbierając opakowania na przyprawy z zupek, na których jest jedna lub dwie kwoty, które należy sumować. Do tej żmudnej operacji przygotowałem narzędzie, które jest zdecydowanie łatwiejsze w użyciu niż kalkulator na stronie producenta.

Wiadomo, że szanse wygranej są na tyle duże, na ile drukowane liczby są spreparowane przez producenta tak, aby sumy dawały okrągłe liczby tylko dla pewnej części opakowań, a z tego co zdążyłem zauważyć pula liczb jest dość ograniczona dając bardzo przewidywalne ilości wygranych. Z mojej puli liczb, nawet powtórzonej kilkukrotnie, nie udało się uzyskać żadnej wygranej. Pomimo tego spróbować można, w końcu zupki Amino nie są takie złe :)

Kalkulator korzysta ze słownika liczb umieszczonego w folderze z programem, o nazwie "amino.txt", który wczytuje przy otwieraniu programu i zapisuje przy zamykaniu, aby ułatwić zarządzanie swoją indywidualną pulą liczb. Liczby wprowadza się w nowych liniach lub przez oddzielenie spacjami, a słowa które nie są liczbami są pomijane. Parametry wyliczania można zmienić, jeśli kiedyś powstanie inna podobna loteria. Przycisk wylicz powoduje wyszukanie wygranych, znajdywane są wszystkie kombinacje liczb (również wielokrotne wystąpienia tych samych) i wiadomo - lepiej wybrać najwyższą lub zebrać więcej opakowań i poczekać na jeszcze wyższą.

Dołączam też źródła programu z licencją "róbta co chceta" w zamian za podziękowanie w komentarzu.

Aktualizacja

Ponieważ program nie działał wystarczająco szybko przy dużej ilości wprowadzonych liczb, przerobiłem go tak aby używał HashSet i wyznaczał wartość hash dla szukanych sum:


int hash = (nums.IndexOf(item) + 1) * num.Value;
int sumHash = hash1 ^ hash2;

Aktualizacja

Na stronie http://www.e-konkursy.info/forum/post-870037-cat-1-pg-20.html jest umieszczony wątek na temat konkursu. Z kwot uzbieranych przez forumowiczów jasno wynika, że gdy liczba znaleziona w opakowaniu jest podzielna przez 11 wygranej nie będzie, gdyż suma dowolnych liczb podzielnych przez 11 nie da wielokrotności liczby 1000 mniejszej niż 11000. Tak czy inaczej kalkulator pomoże znaleźć kombinację liczb dającą najwyższą wygraną, jeśli łut szczęścia dopisze i trafimy na liczbę niepodzielną przez 11. Powodzenia !

Aktualizacja 24.09.2009 (wersja 2.0)

Przygotowałem kolejną wersję programu, która w porównaniu z poprzednią nie pokazuje powtarzających się wygranych, liczy dużo pewniej niż poprzednia i zdecydowanie szybciej. Uaktualniony jest też kod źródłowy programu do pobrania (amino_source.zip). Wszystkich zgłoszonych błędów już nie ma, ale oczywiście do uruchomienia programu potrzebny jest .Net framework 3.5 SP1 - (http://www.microsoft.com/downloads/details.aspx?FamilyID=AB99342F-5D1A-413D-8319-81DA479AB0D7&displaylang=pl)

Aktualizacja 15.10.2009 (wersja 2.5)

W związku z licznymi prośbami o szybsze działanie programu dziś powstała nowa wersja, która przed wyszukaniem kombinacji liczb szuka liczb podzielnych przez 11 i jeśli wszystkie liczby są podzielne przez 11, informuje, że nie znaleziono wygranej. Oczywiście liczbę 11 można zmienić lub nie wpisać jej wcale. W prawdzie jest to tylko ominięcie problemu, ale dla loterii jest całkiem skuteczne - jeśli masz dużo liczb i program się zawiesi przy liczeniu to prawdopodobnie masz wygraną :)
Przyspieszenie liczenia kombinacji jest możliwe, ale wymaga stosowania bardziej złożonych technik liczenia kombinacji, a "brutalne" liczenie (prawie) wszystkich kombinacji użyte w programie jest bardzo czasochłonne stąd mała jego wydajność - ilość obliczeń dla każdej kolejnej ilości wygranych liczb wyznaczana jest według wzoru: http://pl.wikipedia.org/wiki/Kombinacja_bez_powtórzeń

Aktualizacja 22.11.2009

Do sprawdzania podzielności kwot przez 11 i szukania potencjalnych wygranych przygotowałem kalkulator online, który we wprowadzonym tekście wyszukuje kwoty trzy i czterocyfrowe, które mogą dać wygraną. Zbieżność dnia i miesiąca dzisiejszej daty z podzielnością w loterii amino jest czysto przypadkowa :)

Aktualizacja 29.12.2009

Ponieważ loteria dobiega końca, udostępniłem do pobrania kalkulator onima.exe, który 2-3 miesiące temu był wystawiony na allegro, a w międzyczasie został dopracowany. Kalkulator jest szybki i bezbłędny, polecam.

Aktualizacja 18.07.2010

Witam wszystkich! Nie miałem możliwości śledzenia losów nowej loterii, więc aktualizuję stronę dopiero teraz. Tym razem loterię sponsoruje liczba 13, więc zrobiłem kilka zmian - szukanie liczb podzielnych przez 13 działa od dzisiaj na stronie w forumlarzu poniżej, można szybko sprawdzić czy mamy wygrywającą liczbę. W pobieralni wrzuciłem onima2010.exe, który liczy zgodnie z zasadami nowej loterii i znajduje kombinacje liczb dające wygraną. Niestety nie gwarantuję, że program działa poprawnie, gdyż piszę z wysp i nie widziałem loterii na oczy, sugeruję się tylko tym co piszecie poniżej. Powodzenia!

Aktualizacja 20.07.2010

Jeszcze o licencji: kalkulator onima (2009 i 2010) jest i będzie darmowy, możecie go używać bez ograniczeń, jednak nie można go sprzedawać, modyfikować czy podszywać się pod autora. Jeśli ktoś z Was znajdzie onima2010 w sprzedaży na Allegro, Ebay lub innym serwisie aukcyjno-ogłoszeniowym, dajcie znać w komentarzach, a najlepiej od razu zgłoście do obsługi tego serwisu jako naruszenie regulaminu. Dzięki, pozdrawiam.

Wyszukiwarka liczb wygrywających
Wprowadź do pola poniżej liczby, oddzielone dowolnymi znakami i naciśnij Szukaj.

Wklej tekst do pola powyżej i naciśnij przycisk "Wylicz" ...

Attachment	Size
onima.exe - wydajny kalkulator (loteria 2009)	20 KB
onima2010.exe	20 KB

download

programming

Compilation of PostgreSQL 8.3.7 on Visual Studio 2008

Michał Turecki — Sun, 17 May 2009 11:39:21 +0000

Today I have encountered few problems while trying to compile PostgreSQL on Windows. PostgreSQL designed to work in *nix environments and it's native build system works flawlessly on Linux just as expected. Unfortunatelly on Windows this build system is used by minority of applications, partially using Microsoft's own version of make: nmake.

In PostgreSQL only libpq.dll can be compiled using nmake in Visual Studio Command Prompt which sets all necessary environment variables for compiler and linker (INCLUDE, LIBPATH etc, type set in command prompt to verify these paths).

Make sure you have installed most recent version of the Windows SDK before compiling postgresql, current version is 6.1 and it's default installation path is C:\Program Files\Microsoft SDKs\Windows\v6.1. To compile only libpq.dll in command prompt type following:

nmake /f win32.mak
or optionally:
nmake /f win32.mak DEBUG=1

To build whole project you need to satisfy all requirements regarding win32 build, specified in PostgresSQL documentation ( http://www.postgresql.org/docs/8.3/interactive/install-win32-full.html ). I used ActiveState Perl, but as mentioned in documentation standard distribution would be sufficient, just be sure to update src\tools\msvc\Mkvcbuild.pm if perl version differs from 5.8 ( replace \lib\CORE\perl58.lib with valid perl library path ). When installing these requirements you can specify same folder for all installations, even ActiveState Perl, for example C:\pgbuild, then only bin directory in C:\pgbuild folder must be added to PATH environment variable so all tools could be found by PostgreSQL build scripts.

PostgreSQL 8.3.7 default win32 build scripts are prepared for Visual Studio 8 (2005) and Windows Platform SDK obsoleted by Windows SDK so few changes are necessary to build PostgreSQL:

In Project.pm replace ProjectType="Visual C++" Version="8.00" with ProjectType="Visual C++" Version="9.00"
In src\include\port\win32.h replace #define _WIN32_WINNT 0x0500 with #define _WIN32_WINNT 0x0501 to satisfy requirement for IPPROTO_IPV6 conditionally defined in Windows SDK. Updating src\include\pg_config_os.h might be also necessary.
To build libpq.dll I have needed to supply src\interfaces\libpq\libpq.rc file by copying it from src\interfaces\libpq\libpq.rc.in, elegant solution would be to add:
"libpq.rc" : if not exist "libpq.rc" copy "libpq.rc.in" "libpq.rc"
to src\interfaces\libpq\win32.mak just before line beginning with: CPP_PROJ=.
Update paths in src\tools\msvc\config.pl to match previously installed dependencies.

To build PostgreSQL just type build in Visual Studio Command Prompt in src\tools\msvc folder. All possible problems would appear yellow and red and generally would be simple to solve by satisfying dependencies like include files (eg. zlib.h) or required libraries (zlib.lib and zdll.lib which need to be grabbed from the net).

Take a look at other tools in src\tools\msvc, clean would be your inseparable friend and install with destination folder passed as parameter will ease an installation of your fresh PostgreSQL build.

Have fun hacking pg and feel free to comment your experiences.

programming

windows

	URL
	Base 64
	Hex

Michał Turecki - programming

SQL Server useful but less known features

Checking who is connected to the database

Adjusting connection pooling settings

Checking the size of column's contents

Using SQL Server profiler

Online encode and decode base64, hex, url

On Protobuf.Net, using AsReference and multiple instances of object which should be deserialized only once.

FlowDocument from a different thread - "The calling thread cannot access this object because a different thread owns it."

Delphi 2007 - error running on 64-bit Windows

TortoiseMerge with better shortcuts, like WinMerge

Simple themed TCheckComboBox control for Delphi - TComboBox with checkboxes

Kalkulator wygranych amino lotto 2009 oraz 2010

Compilation of PostgreSQL 8.3.7 on Visual Studio 2008