Convert integer to hex und hex zu integer

Also ich habe diese Abfrage funktioniert (wo signal_data eine Spalte) in Sybase-aber es funktioniert nicht in Microsoft SQL Server:

HEXTOINT(SUBSTRING((INTTOHEX(signal_data)),5,2)) as Signal

Außerdem habe ich es in Excel (wo A1 enthält den Wert):

=HEX2DEC(LEFT(DEC2HEX(A1),LEN(DEC2HEX(A1))-2))

Weiß jemand, wie ich dies in SQL Server?

InformationsquelleAutor Nick Sinas | 2009-03-31

104

Konvertieren von INT zu hex:
```
SELECT CONVERT(VARBINARY(8), 16777215)
```
Konvertieren von hex zu INT:
```
SELECT CONVERT(INT, 0xFFFFFF)
```
Update 2015-03-16

Obigen Beispiel hat die Einschränkung, dass es nur funktioniert, wenn der HEX-Wert wird als integer-literal. Der Vollständigkeit halber, wenn der Wert zu konvertieren ist ein hexadezimal-string (z.B. in einer varchar-Spalte) verwenden:
```
-- If the '0x' marker is present:
SELECT CONVERT(INT, CONVERT(VARBINARY, '0x1FFFFF', 1))

-- If the '0x' marker is NOT present:
SELECT CONVERT(INT, CONVERT(VARBINARY, '1FFFFF', 2))
```
Hinweis: muss Die Zeichenfolge enthalten, die eine gerade Anzahl von hex-Ziffern. Eine ungerade Anzahl von Ziffern ergeben einen Fehler.

Mehr details finden Sie in der "Binären Styles" Abschnitt des CAST und CONVERT (Transact-SQL). Ich glaube, dass SQL Server 2008 oder höher ist erforderlich.

Umwandlung in VARBINARY geben Daten in hex-Wert . String-Operationen können nicht durchgeführt werden
Karwin, Pavan korrekt ist. Sql Server 2008 kann dies über die convert Funktion aber 2005 und unten nicht.
Bei Verwendung von 8-Hex-Zeichen, wie mit ARGB umwandeln BIGINT anstatt INT. Der max-Wert für INT ist nur 2,147,483,647, oder 7FFFFFFF. Vorsicht bei der Verwendung von INT, die round trip zurück auf hex funktioniert, aber die Ergebnisse sind unterschiedlich von Excel Hex2Dec.
SELECT CONVERT(INT, CONVERT(varbinary, '01', 2)) zurück 12337 (SQL Server 2005)

InformationsquelleAutor Bill Karwin
43

Eigentlich die eingebaute Funktion namens Meister.dbo.fn_varbintohexstr.

So, zum Beispiel:
```
SELECT 100, master.dbo.fn_varbintohexstr(100)
```
Gibt Sie

100 0x00000064

Siehe dba.stackexchange.com/questions/46910/... auf die Nachteile.
Die meisten der 'cons' - abgesehen von der fehlenden Dokumentation/Spezifikation - sound wie BS!.

InformationsquelleAutor justinpitts

SQL Server-äquivalente zu Excel ist string-basiert, DEC2HEX, HEX2DEC Funktionen:

--Convert INT to hex string:
PRINT CONVERT(VARCHAR(8),CONVERT(VARBINARY(4), 16777215),2) --DEC2HEX

--Convert hex string to INT:
PRINT CONVERT(INT,CONVERT(VARBINARY(4),'00FFFFFF',2)) --HEX2DEC

InformationsquelleAutor Kip Bryan

12

Konvertieren von int zu hex:

SELECT FORMAT(512+255,'X')

Seit SQL Server 2012-nur: msdn.microsoft.com/en-us/library/hh213505.aspx
Und der Fall von " X " bestimmt den Fall des hex-Ausgabe. bis gestimmt.

InformationsquelleAutor DenNukem
7

Ist es möglich, über die Funktion FORMAT verfügbar, die auf SQL Server 2012 und höher
```
select FORMAT(10,'x2')
```
Ergebnisse in:
```
0a
```
InformationsquelleAutor wndproc
5

Das traditionelle 4-bit-hex ist ziemlich direkt.
Hex-String in Integer (Vorausgesetzt, der Wert wird gespeichert, im Feld " FHexString) :
```
CONVERT(BIGINT,CONVERT(varbinary(4),
                (SELECT master.dbo.fn_cdc_hexstrtobin(

                    LEFT(FMEID_ESN,8)                       
                ))
                ))
```
Integer-to-Hex-String (Vorausgesetzt, der Wert wird gespeichert, im Feld " FInteger):
```
(SELECT master.dbo.fn_varbintohexstr(CONVERT(varbinary,CONVERT(int,
                    FInteger
                ))))
```
Wichtig zu beachten ist, dass, wenn Sie beginnen, verwenden Sie bit-Größen, die Ursache register-sharing, insbesondere auf einem intel-Rechner, Ihre High und Low und Linke und Rechte in die Register getauscht werden, aufgrund der little-endian-Natur von Intel. Wenn beispielsweise eine varbinary(3), wir reden über ein 6 Hex-Zeichen. In diesem Fall, Ihre bits gekoppelt sind, wie die folgenden Indizes von rechts nach Links "54,32,10". In einem intel-system, die Sie erwarten würden, "76,54,32,10". Da Sie nur mit 6 von den 8, die Sie sich merken müssen, zu tun, die swaps selbst. "76,54" qualifizieren sich als Links und "32,10" qualifizieren als Ihre Rechte. Das Komma trennt Ihre high und low. Intel tauscht die hoch und Tiefs, dann ist die linke und die Rechte. So zu tun, eine Umstellung...seufz, haben Sie, um Sie zu tauschen, Euch zum Beispiel den folgenden wandelt die ersten 6 von 8 hex-Zeichen:
```
(SELECT master.dbo.fn_replvarbintoint(
                CONVERT(varbinary(3),(SELECT master.dbo.fn_cdc_hexstrtobin(
                    --intel processors, registers are switched, so reverse them 


                    ----second half
                    RIGHT(FHex8,2)+ --0,1 (0 indexed)
                    LEFT(RIGHT(FHex8,4),2)+ -- 2,3 (oindex)
                    --first half
                    LEFT(RIGHT(FHex8,6),2) --4,5

                )))
                ))
```
Es ist ein bisschen kompliziert, so dass ich versuchen würde, um meine Umbauten zu 8 hex-Zeichen (varbinary(4)).

In der Zusammenfassung, dies sollte Ihre Frage beantworten. Umfassend.

InformationsquelleAutor Neel Edwards

Hier ist die Funktion für die SQL-server wandelt die integer-Wert in seine hexadezimale Darstellung als varchar. Es sollte sich leicht anpassen, um andere Datenbank-Typen

Beispiel:

SELECT dbo.ToHex(4095) --> FFF

SQL:

CREATE FUNCTION ToHex(@value int)
RETURNS varchar(50)
AS
BEGIN
    DECLARE @seq char(16)
    DECLARE @result varchar(50)
    DECLARE @digit char(1)
    SET @seq = '0123456789ABCDEF'

    SET @result = SUBSTRING(@seq, (@value%16)+1, 1)

    WHILE @value > 0
    BEGIN
        SET @digit = SUBSTRING(@seq, ((@value/16)%16)+1, 1)

        SET @value = @value/16
        IF @value <> 0 SET @result = @digit + @result
    END 

    RETURN @result
END
GO

Es funktioniert! Perfekt! Sie müssen nur ersetzen, "@ value 0" durch "@ value <> 0"
die Formatierung ist nun behoben.
Ich mag diese Lösung, weil es leicht modifizierbar in eine noch mächtigere. Ich lieferte so ein Beispiel Lösung von mit der Länge der Sequenz als Basis.

InformationsquelleAutor Maksym Kozlenko

Declare @Dato xml
Set @Dato = Convert(xml, '<dato>FF</dato>')
Select Cast( rw.value( 'xs:hexBinary( text()[1])' , 'varbinary(max)' ) as int ) From @Dato.nodes('dato') as T(rw)

Dies hat den Vorteil der Zusammenarbeit auf SQL Server 2005.

InformationsquelleAutor Donaciano

2

Verwenden master.dbo.fnbintohexstr(16777215) zu konvertieren, um ein varchar Darstellung.

select master.sys.fn_varbintohexstr(1) im Jahr 2008

InformationsquelleAutor

Die Antwort von Maksym Kozlenko ist schön und kann leicht modifiziert behandeln Codierung einen numerischen Wert zu jedem code-format. Zum Beispiel:

CREATE FUNCTION [dbo].[IntToAlpha](@Value int)
RETURNS varchar(30)
AS
BEGIN
    DECLARE @CodeChars varchar(100) 
    SET @CodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    DECLARE @CodeLength int = 26
    DECLARE @Result varchar(30) = ''
    DECLARE @Digit char(1)

    SET @Result = SUBSTRING(@CodeChars, (@Value % @CodeLength) + 1, 1)
    WHILE @Value > 0
    BEGIN
        SET @Digit = SUBSTRING(@CodeChars, ((@Value / @CodeLength) % @CodeLength) + 1, 1)
        SET @Value = @Value / @CodeLength
        IF @Value <> 0 SET @Result = @Digit + @Result
    END 

    RETURN @Result
END

So, eine große Zahl wie 150 Millionen, wird nur aus 6 Zeichen (150,000,000 = "MQGJMU")

Konnte man auch mit verschiedenen Charakteren in verschiedenen Sequenzen, wie ein Verschlüsselndes Gerät. Oder pass in die code-Zeichen und die Länge der Zeichen und verwenden Sie als Salzen Methode für die Verschlüsselung.

- Und auf der Rückseite:

CREATE FUNCTION [dbo].[AlphaToInt](@Value varchar(7))
RETURNS int
AS
BEGIN
    DECLARE @CodeChars varchar(100) 
    SET @CodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    DECLARE @CodeLength int = 26
    DECLARE @Digit char(1)
    DECLARE @Result int = 0
    DECLARE @DigitValue int
    DECLARE @Index int = 0
    DECLARE @Reverse varchar(7)
    SET @Reverse = REVERSE(@Value)

    WHILE @Index < LEN(@Value)
    BEGIN
        SET @Digit = SUBSTRING(@Reverse, @Index + 1, 1)
        SET @DigitValue = (CHARINDEX(@Digit, @CodeChars) - 1) * POWER(@CodeLength, @Index)
        SET @Result = @Result + @DigitValue
        SET @Index = @Index + 1
    END 
    RETURN @Result

InformationsquelleAutor Jason Gilley

Gegeben:

declare @hexStr varchar(16), @intVal int

IntToHexStr:

select @hexStr = convert(varbinary, @intVal, 1)

HexStrToInt:

declare
    @query varchar(100),
    @parameters varchar(50)

select
    @query = 'select @result = convert(int,' + @hb + ')',
    @parameters = '@result int output'

exec master.dbo.Sp_executesql @query, @parameters, @intVal output

InformationsquelleAutor Bob Platt

IIF(Fields!HIGHLIGHT_COLOUR.Value="","#FFFFFF","#" & hex(Fields!HIGHLIGHT_COLOUR.Value) & StrDup(6-LEN(hex(Fields!HIGHLIGHT_COLOUR.Value)),"0"))

Ist die Arbeit für mich als ein Ausdruck der schriftart, Farbe

InformationsquelleAutor Julian

Konvertieren Hex-strings in INT -, habe ich dieses in der Vergangenheit. Es kann geändert werden, um zu konvertieren jede base INT in der Tat (Oktal -, Binär -, was auch immer)

Declare @Str varchar(200)
Set @str = 'F000BE1A'

Declare @ndx int
Set @ndx = Len(@str)
Declare @RunningTotal  BigInt
Set @RunningTotal = 0

While @ndx > 0
Begin
    Declare @Exponent BigInt
    Set @Exponent = Len(@Str) - @ndx

    Set @RunningTotal = @RunningTotal + 

    Power(16 * 1.0, @Exponent) *
    Case Substring(@str, @ndx, 1)
        When '0' then 0
        When '1' then 1
        When '2' then 2 
        When '3' then 3
        When '4' then 4
        When '5' then 5
        When '6' then 6
        When '7' then 7
        When '8' then 8
        When '9' then 9
        When 'A' then 10
        When 'B' then 11
        When 'C' then 12
        When 'D' then 13
        When 'E' then 14
        When 'F' then 15
    End
    Set @ndx = @ndx - 1
End

Print @RunningTotal

InformationsquelleAutor j_s_kelley

Unten sind zwei Funktionen: dbo.HexToInt und dbo.IntToHex, ich benutze Sie für eine solche Umwandlung:

if OBJECT_ID('dbo.HexToInt') is not null
    drop function dbo.HexToInt
GO
create function dbo.HexToInt (@chars varchar(max))
returns int
begin
    declare @char varchar(1), @len int, @i int, @r int, @tmp int, @pow int
    set @chars = RTRIM(LTRIM(@chars))
    set @len = LEN(@chars)
    set @i = 1
    set @r = 0
    while @i <= @len
    begin
        set @pow = @len - @i
        set @char = SUBSTRING(@chars, @i, 1)
        if @char = '0'
            set @tmp = 0
        else if @char = '1'
            set @tmp = 1
        else if @char = '2'
            set @tmp = 2
        else if @char = '3'
            set @tmp = 3
        else if @char = '4'
            set @tmp = 4
        else if @char = '5'
            set @tmp = 5
        else if @char = '6'
            set @tmp = 6
        else if @char = '7'
            set @tmp = 7
        else if @char = '8'
            set @tmp = 8
        else if @char = '9'
            set @tmp = 9
        else if @char = 'A'
            set @tmp = 10
        else if @char = 'B'
            set @tmp = 11
        else if @char = 'C'
            set @tmp = 12
        else if @char = 'D'
            set @tmp = 13
        else if @char = 'E'
            set @tmp = 14
        else if @char = 'F'
            set @tmp = 15
        set @r = @r + @tmp * POWER(16,@pow)
        set @i = @i + 1     
    end
    return @r
end

Und das zweite:

if OBJECT_ID('dbo.IntToHex') is not null
    drop function dbo.IntToHex
GO
create function dbo.IntToHex (@val int)
returns varchar(max)
begin
    declare @r varchar(max), @tmp int, @v1 int, @v2 int, @char varchar(1)
    set @tmp = @val
    set @r = ''
    while 1=1
    begin
        set @v1 = @tmp / 16
        set @v2 = @tmp % 16
        if @v2 = 0
            set @char = '0'
        else if @v2 = 1
            set @char = '1'
        else if @v2 = 2
            set @char = '2'
        else if @v2 = 3
            set @char = '3'
        else if @v2 = 4
            set @char = '4'
        else if @v2 = 5
            set @char = '5'
        else if @v2 = 6
            set @char = '6'
        else if @v2 = 7
            set @char = '7'
        else if @v2 = 8
            set @char = '8'
        else if @v2 = 9
            set @char = '9'
        else if @v2 = 10
            set @char = 'A'
        else if @v2 = 11
            set @char = 'B'
        else if @v2 = 12
            set @char = 'C'
        else if @v2 = 13
            set @char = 'D'
        else if @v2 = 14
            set @char = 'E'
        else if @v2 = 15
            set @char = 'F'
        set @tmp = @v1 
        set @r = @char + @r
        if @tmp = 0
            break
    end
    return @r
end

InformationsquelleAutor byte

Maksym Kozlenko hat eine schöne Lösung, und die anderen kommen in der Nähe entriegeln Sie das volle potential aber dann vermisse völlig klar, dass Sie es kann eine beliebige Sequenz von Zeichen, und verwenden es Länge wie die Basis. Das ist, warum ich mag dieses leicht modifizierte version seiner Lösung, weil es für base 16-oder base-17, - und etc.

Was zum Beispiel, wenn Sie wollten, Buchstaben und zahlen, aber nicht, wie ich ' s für suchen wie 1 ist und O ist für uns wie 0 ist. Sie kann eine beliebige Sequenz auf diese Weise. Unten ist eine form von "Basis 36" überspringt die I und O für eine "modifizierte base 34". Un-Kommentar die hex-Linie statt zu laufen als hex.

declare @value int = 1234567890

DECLARE @seq varchar(100) = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ' -- modified base 34
--DECLARE @seq varchar(100) = '0123456789ABCDEF' -- hex
DECLARE @result varchar(50)
DECLARE @digit char(1)
DECLARE @baseSize int = len(@seq)
DECLARE @workingValue int = @value

SET @result = SUBSTRING(@seq, (@workingValue%@baseSize)+1, 1)

WHILE @workingValue > 0
BEGIN
    SET @digit = SUBSTRING(@seq, ((@workingValue/@baseSize)%@baseSize)+1, 1)

    SET @workingValue = @workingValue/@baseSize
    IF @workingValue <> 0 SET @result = @digit + @result
END 

select @value as Value, @baseSize as BaseSize, @result as Result

Wert, BaseSize, Ergebnis

1234567890, 34, T5URAA

Ich zog auch Wert über einer funktionierenden Wert, und dann arbeiten aus der Arbeits-Wert zu kopieren, als eine persönliche Vorliebe.

Unten ist zusätzlich für die Umkehrung der transformation, für jede Sequenz, mit der Basis, definiert als die Länge der Sequenz.

declare @value varchar(50) = 'T5URAA'

DECLARE @seq varchar(100) = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ' -- modified base 34
--DECLARE @seq varchar(100) = '0123456789ABCDEF' -- hex
DECLARE @result int = 0
DECLARE @digit char(1)
DECLARE @baseSize int = len(@seq)
DECLARE @workingValue varchar(50) = @value

DECLARE @PositionMultiplier int = 1
DECLARE @digitPositionInSequence int = 0

WHILE len(@workingValue) > 0
BEGIN
    SET @digit = right(@workingValue,1)
    SET @digitPositionInSequence = CHARINDEX(@digit,@seq)
    SET @result = @result + ( (@digitPositionInSequence -1) * @PositionMultiplier)

    --select @digit, @digitPositionInSequence, @PositionMultiplier, @result

    SET @workingValue = left(@workingValue,len(@workingValue)-1)
    SET @PositionMultiplier = @PositionMultiplier * @baseSize
END 

select @value as Value, @baseSize as BaseSize, @result as Result

InformationsquelleAutor Greg

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update 2015-03-16