MySQL problem?

[GTX]

Hello. Well, my problem is that:

I'm trying to insert a row to table but it doesn't insert "\".

My code looks like that:

query = mysql_query(connect_mysql, "INSERT INTO `"..mapname.."` (name, time, date, serial, tag) VALUES('"..name.."', '"..time.."', '"..date.."', '"..serial.."','".. tag.."')") 

I'm inserting: s/\|GT#abc123X#ffffff# 17:35:015 11/06/2012 *whatever my serial is* #0024DEsA|

Inserts: s/|GT#abc123X#ffffff# 17:35:015 11/06/2012 *whatever my serial is* #0024DEsA|

Thanks in advance.

[Kenix]

..

Edited June 11, 2012 by Guest

[GTX]

Uhm, so, I can't put the "\" into MySQL?

[GTX]

Hmm... I've no idea how to use that in a string.gsub:

outputChatBox(string.gsub("s/\|GT#abc123X#ffffff#", "\", "\\"))?

EDIT: I got it, thanks.

[GTX]

Sorry for triple post but... I've no idea why it doesn't insert the "\". Tried with:

  
local name = string.gsub(getPlayerName(name), "s/\|", "s/\\|") 
query = mysql_query(connect_mysql, "INSERT INTO `"..mapname.."` (name, time, date, serial, tag) VALUES('"..name.."', '"..time.."', '"..date.."', '"..serial.."','".. tag.."')") 

[myonlake]

Do not triple post then, edit your previous posts.

[Guest Guest4401]

outputChatBox"s/\|GT#abc123X#ffffff#" 
--> s/|GT#abc123X#ffffff# 
  
outputChatBox[[s/\|GT#abc123X#ffffff#]] 
--> s/\|GT#abc123X#ffffff# 

Literal strings can be delimited by matching single or double quotes, and can contain the following C-like escape sequences: '\a' (bell), '\b' (backspace), '\f' (form feed), '\n' (newline), '\r' (carriage return), '\t' (horizontal tab), '\v' (vertical tab), '\\' (backslash), '\"' (quotation mark [double quote]), and '\'' (apostrophe [single quote]). A backslash followed by a real newline results in a newline in the string. The escape sequence '\z' skips the following span of white-space characters, including line breaks; it is particularly useful to break and indent a long literal string into multiple lines without adding the newlines and spaces into the string contents.

A byte in a literal string can also be specified by its numerical value. This can be done with the escape sequence \xXX, where XX is a sequence of exactly two hexadecimal digits, or with the escape sequence \ddd, where ddd is a sequence of up to three decimal digits. (Note that if a decimal escape is to be followed by a digit, it must be expressed using exactly three digits.) Strings in Lua can contain any 8-bit value, including embedded zeros, which can be specified as '\0'.

Literal strings can also be defined using a long format enclosed by long brackets. We define an opening long bracket of level n as an opening square bracket followed by n equal signs followed by another opening square bracket. So, an opening long bracket of level 0 is written as [[, an opening long bracket of level 1 is written as [=[, and so on. A closing long bracket is defined similarly; for instance, a closing long bracket of level 4 is written as ]====]. A long literal starts with an opening long bracket of any level and ends at the first closing long bracket of the same level. It can contain any text except a closing bracket of the proper level. Literals in this bracketed form can run for several lines, do not interpret any escape sequences, and ignore long brackets of any other level. Any kind of end-of-line sequence (carriage return, newline, carriage return followed by newline, or newline followed by carriage return) is converted to a simple newline.

When parsing a from a string source, any byte in a literal string not explicitly affected by the previous rules represents itself. However, Lua opens files for parsing in text mode, and the system file functions may have problems with some control characters. So, it is safer to represent non-text data as a quoted literal with explicit escape sequences for non-text characters.

For convenience, when the opening long bracket is immediately followed by a newline, the newline is not included in the string. As an example, in a system using ASCII (in which 'a' is coded as 97, newline is coded as 10, and '1' is coded as 49), the five literal strings below denote the same string:

a = 'alo\n123"'

a = "alo\n123\""

a = '\97lo\10\04923"'

a = [[alo

123"]]

a = [==[

alo

123"]==]

[myonlake]

Exactly, I was just about to reply and tell you that you cannot use backslash alone, since backslash is in many languages marked to \n = new line and such.

[GTX]

outputChatBox"s/\|GT#abc123X#ffffff#" 
--> s/|GT#abc123X#ffffff# 
  
outputChatBox[[s/\|GT#abc123X#ffffff#]] 
--> s/\|GT#abc123X#ffffff# 

Literal strings can be delimited by matching single or double quotes, and can contain the following C-like escape sequences: '\a' (bell), '\b' (backspace), '\f' (form feed), '\n' (newline), '\r' (carriage return), '\t' (horizontal tab), '\v' (vertical tab), '\\' (backslash), '\"' (quotation mark [double quote]), and '\'' (apostrophe [single quote]). A backslash followed by a real newline results in a newline in the string. The escape sequence '\z' skips the following span of white-space characters, including line breaks; it is particularly useful to break and indent a long literal string into multiple lines without adding the newlines and spaces into the string contents.

A byte in a literal string can also be specified by its numerical value. This can be done with the escape sequence \xXX, where XX is a sequence of exactly two hexadecimal digits, or with the escape sequence \ddd, where ddd is a sequence of up to three decimal digits. (Note that if a decimal escape is to be followed by a digit, it must be expressed using exactly three digits.) Strings in Lua can contain any 8-bit value, including embedded zeros, which can be specified as '\0'.

Literal strings can also be defined using a long format enclosed by long brackets. We define an opening long bracket of level n as an opening square bracket followed by n equal signs followed by another opening square bracket. So, an opening long bracket of level 0 is written as [[, an opening long bracket of level 1 is written as [=[, and so on. A closing long bracket is defined similarly; for instance, a closing long bracket of level 4 is written as ]====]. A long literal starts with an opening long bracket of any level and ends at the first closing long bracket of the same level. It can contain any text except a closing bracket of the proper level. Literals in this bracketed form can run for several lines, do not interpret any escape sequences, and ignore long brackets of any other level. Any kind of end-of-line sequence (carriage return, newline, carriage return followed by newline, or newline followed by carriage return) is converted to a simple newline.

When parsing a from a string source, any byte in a literal string not explicitly affected by the previous rules represents itself. However, Lua opens files for parsing in text mode, and the system file functions may have problems with some control characters. So, it is safer to represent non-text data as a quoted literal with explicit escape sequences for non-text characters.

For convenience, when the opening long bracket is immediately followed by a newline, the newline is not included in the string. As an example, in a system using ASCII (in which 'a' is coded as 97, newline is coded as 10, and '1' is coded as 49), the five literal strings below denote the same string:

a = 'alo\n123"'

a = "alo\n123\""

a = '\97lo\10\04923"'

a = [[alo

123"]]

a = [==[

alo

123"]==]

How can I put a variable into that?

So:

  
local name = getPlayerName(name) 
outputChatBox[[name]] 
  

?

EDIT: Anyways, it doesn't work.