Provides a way for you to incrementally read and write to BLOB columns in SQLite databases. (SQLiteDatabase).
Data As String
Length As UInt64
The length of the BLOB.
This property is read-only.
Position As UInt64
The position within the BLOB.
This property is read-only.
Close the BLOB when you are finished working with it ensure everything gets written to the database.
EndOfFile As Boolean
Returns True when there's no more data left to read.
This code reads the rows and columns of data from a tab-delimited text file into a ListBox:
Var f As FolderItem Var textInput As TextInputStream Var rowFromFile, oneCell As String f = FolderItem.ShowOpenFileDialog("text/plain") // defined as a FileType If f <> Nil Then textInput = TextInputStream.Open(f) textInput.Encoding = Encodings.UTF8 Do rowFromFile = textInput.ReadLine Var values() As String = rowFromFile.ToArray(Encodings.UTF8.Chr(9)) ListBox1.ColumnCount = values.Count ListBox1.AddRow("") Var col As Integer For Each value As String In values ListBox1.CellTextAt(ListBox1.LastAddedRowIndex, col) = value col = col + 1 End For Loop Until textInput.EndOfFile textInput.Close End If
This example reads each pair of bytes from a file and writes them in reverse order to a new file. The user chooses the source file using the Open-file dialog box and saves the new file using the Save as dialog box. The EOF property is used to terminate the Do...Loop.
Var readFile As FolderItem = FolderItem.ShowOpenFileDialog("text") If readFile <> Nil Then Var ReadStream As BinaryStream = BinaryStream.Open(readFile, False) ReadStream.LittleEndian = True Var writeFile As FolderItem = FolderItem.ShowSaveFileDialog("", "") If writeFile <> Nil Then Var writeStream As BinaryStream = BinaryStream.Create(writeFile, True) writeStream.LittleEndian = True Do Until ReadStream.EndOfFile writeStream.WriteInt8(ReadStream.ReadInt8) Loop writeStream = Nil End If readStream = Nil End If
Immediately sends the contents of internal write buffers to disk or to the output stream.
This function can be useful in point-to-point communication over sockets and similar connections: To optimize for transmission performance, some types of output streams try to collect small pieces of written data into one larger piece for sending instead of sending each piece out individually. By calling Flush, the data collection is stopped and the data is sent without further delay, reducing latency.
When using this on a stream that ends up as a file on disk, it is useful, too: Any short parts of previously written data are written to disk right away, ensuring the data is actually on disk if the application terminates abruptly, e.g. due to a crash.
Avoid calling this method too often. For example, do not call it between successive Write calls because you'll slow down performance without getting much benefit.
A typical use case would look like this:
mySocket.Write("you typed: ") mySocket.Write(key) mySocket.Write(".") mySocket.Flush
Reads Count bytes from the input stream and returns a String.
If provided, the optional parameter Enc specifies the text encoding to be defined for the String to be read.
If Count is higher than the amount of bytes currently available in the stream, all available bytes will be returned. Therefore, make sure to always consider the case that you get less than you requested. To see if you received all requested bytes, check the returned string's String property (avoid using Length as it may give a different number if the encoding is not nil).
If not enough memory is available, you get back an empty string.
This example reads the first 1000 bytes from a BinaryStream.
Var readFile As FolderItem = FolderItem.ShowOpenFileDialog("text/plain") If readFile <> Nil Then Var ReadStream As BinaryStream = BinaryStream.Open(readFile, False) ReadStream.LittleEndian = True TextArea1.Text = ReadStream.Read(1000, Encodings.UTF8) End If
Write(Data As String)
Writes the passed data to the output stream.
Note that in order to make sure that the data actually ends up on disk or gets sent to the socket it is connected to, the stream must either get closed or the Flush method be called. Otherwise, the data, if small, may end up temporarily in a write buffer before either a certain time has passed or more data is written. This buffering increases performance when writing lots of small pieces of data, but may be causing unwanted delays when another process, e.g. the other end of a socket connection, is waiting for the data. Consider calling the Flush method to reduce latencies that this buffering may cause in such cases.
If Write fails, an IOException will be raised.
This example displays the Save As dialog box and writes the contents of the TextArea1 to a text file.
Var f As FolderItem Var stream As BinaryStream f = FolderItem.ShowSaveFileDialog(FileTypes1.Text, "Untitled.txt") If f<> Nil Then stream = BinaryStream.Create(f, True) stream.Write(TextArea1.Text) stream.Close End If
This example reads the Logo (stored as a binary picture) from the Logo column for rowID = 1 in the Team table:
Var blob As SQLiteBLOB blob = db.OpenBlob("Team", "Logo", 1, True) If blob <> Nil Then Try Var data As String While Not blob.EndOfFile data = data + blob.Read(1000) Wend blob.Close Var mb As MemoryBlock mb = data Var logoPic As Picture = Picture.FromData(mb) Catch error As IOException MessageBox("Error while reading BLOB: " + error.Message) End Try End If
All project types on all supported operating systems.